diff --git a/A4/TP_GPU-master/TP1_image/CUDA/CMakeLists.txt b/A4/TP_GPU-master/TP1_image/CUDA/CMakeLists.txt index 7e986ca..f95bea6 100644 --- a/A4/TP_GPU-master/TP1_image/CUDA/CMakeLists.txt +++ b/A4/TP_GPU-master/TP1_image/CUDA/CMakeLists.txt @@ -5,7 +5,8 @@ set(ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/) #set(CMAKE_C_COMPILER "gcc-8") #set(CMAKE_CXX_COMPILER "g++-8") -#set(CUDA_TOOLKIT_ROOT_DIR "/usr/local/cuda") +set(CUDA_TOOLKIT_ROOT_DIR "/usr/local/cuda-11.7/") +set(CMAKE_CUDA_COMPILER "/usr/local/cuda-11.7/bin/nvcc") list(APPEND HEADER_REP ${ROOT_DIR}/ ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES} "/usr/local/cuda/samples/common/inc/" "${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES}/../samples/common/inc") @@ -15,7 +16,6 @@ file(GLOB_RECURSE HEADER_FILES ${ROOT_DIR}/*.cuh ${ROOT_DIR}/*.h) set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --use_fast_math") - set(CUDA_SEPARABLE_COMPILATION ON) set(CUDA_NVCC_FLAGS "-lineinfo;-I\"${ROOT_DIR}/inc\" -I\"${ROOT_DIR}/\" -I\"/usr/local/cuda/samples/common/inc/\"") diff --git a/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeCache.txt b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeCache.txt new file mode 100644 index 0000000..4fbed9c --- /dev/null +++ b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeCache.txt @@ -0,0 +1,354 @@ +# This is the CMakeCache file. +# For build in directory: /home/higepi/Documents/M2R_SETI/M2_SETI/A4/TP_GPU-master/TP1_image/CUDA/build +# It was generated by CMake: /usr/bin/cmake +# You can edit this file to change values found and used by cmake. +# If you do not want to change any of the values, simply exit the editor. +# If you do want to change a value, simply edit, save, and exit the editor. +# The syntax for the file is as follows: +# KEY:TYPE=VALUE +# KEY is the name of a variable in the cache. +# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!. +# VALUE is the current value for the KEY. + +######################## +# EXTERNAL cache entries +######################## + +//Path to a program. +CMAKE_ADDR2LINE:FILEPATH=/usr/bin/addr2line + +//Path to a program. +CMAKE_AR:FILEPATH=/usr/bin/ar + +//Choose the type of build, options are: None Debug Release RelWithDebInfo +// MinSizeRel ... +CMAKE_BUILD_TYPE:STRING= + +//Enable/Disable color output during build. +CMAKE_COLOR_MAKEFILE:BOOL=ON + +//CUDA compiler +CMAKE_CUDA_COMPILER:FILEPATH=/usr/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= + +//Flags used by the CUDA compiler during MINSIZEREL builds. +CMAKE_CUDA_FLAGS_MINSIZEREL:STRING= + +//Flags used by the CUDA compiler during RELEASE builds. +CMAKE_CUDA_FLAGS_RELEASE:STRING= + +//Flags used by the CUDA compiler during RELWITHDEBINFO builds. +CMAKE_CUDA_FLAGS_RELWITHDEBINFO:STRING= + +//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-9 + +//A wrapper around 'ranlib' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_CXX_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib-9 + +//Flags used by the CXX compiler during all build types. +CMAKE_CXX_FLAGS:STRING= + +//Flags used by the CXX compiler during DEBUG builds. +CMAKE_CXX_FLAGS_DEBUG:STRING=-g + +//Flags used by the CXX compiler during MINSIZEREL builds. +CMAKE_CXX_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG + +//Flags used by the CXX compiler during RELEASE builds. +CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG + +//Flags used by the CXX compiler during RELWITHDEBINFO builds. +CMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG + +//Path to a program. +CMAKE_DLLTOOL:FILEPATH=CMAKE_DLLTOOL-NOTFOUND + +//Flags used by the linker during all build types. +CMAKE_EXE_LINKER_FLAGS:STRING= + +//Flags used by the linker during DEBUG builds. +CMAKE_EXE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during MINSIZEREL builds. +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during RELEASE builds. +CMAKE_EXE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during RELWITHDEBINFO builds. +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Enable/Disable output of compile commands during generation. +CMAKE_EXPORT_COMPILE_COMMANDS:BOOL=OFF + +//Install path prefix, prepended onto install directories. +CMAKE_INSTALL_PREFIX:PATH=/usr/local + +//Path to a program. +CMAKE_LINKER:FILEPATH=/usr/bin/ld + +//Path to a program. +CMAKE_MAKE_PROGRAM:FILEPATH=/usr/bin/make + +//Flags used by the linker during the creation of modules during +// all build types. +CMAKE_MODULE_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of modules during +// DEBUG builds. +CMAKE_MODULE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of modules during +// MINSIZEREL builds. +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of modules during +// RELEASE builds. +CMAKE_MODULE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of modules during +// RELWITHDEBINFO builds. +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_NM:FILEPATH=/usr/bin/nm + +//Path to a program. +CMAKE_OBJCOPY:FILEPATH=/usr/bin/objcopy + +//Path to a program. +CMAKE_OBJDUMP:FILEPATH=/usr/bin/objdump + +//Value Computed by CMake +CMAKE_PROJECT_DESCRIPTION:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_HOMEPAGE_URL:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_NAME:STATIC=seuillage + +//Path to a program. +CMAKE_RANLIB:FILEPATH=/usr/bin/ranlib + +//Path to a program. +CMAKE_READELF:FILEPATH=/usr/bin/readelf + +//Flags used by the linker during the creation of shared libraries +// during all build types. +CMAKE_SHARED_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of shared libraries +// during DEBUG builds. +CMAKE_SHARED_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of shared libraries +// during MINSIZEREL builds. +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELEASE builds. +CMAKE_SHARED_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELWITHDEBINFO builds. +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//If set, runtime paths are not added when installing shared libraries, +// but are added when building. +CMAKE_SKIP_INSTALL_RPATH:BOOL=NO + +//If set, runtime paths are not added when using shared libraries. +CMAKE_SKIP_RPATH:BOOL=NO + +//Flags used by the linker during the creation of static libraries +// during all build types. +CMAKE_STATIC_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of static libraries +// during DEBUG builds. +CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of static libraries +// during MINSIZEREL builds. +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of static libraries +// during RELEASE builds. +CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of static libraries +// during RELWITHDEBINFO builds. +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_STRIP:FILEPATH=/usr/bin/strip + +//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 + +//Value Computed by CMake +seuillage_BINARY_DIR:STATIC=/home/higepi/Documents/M2R_SETI/M2_SETI/A4/TP_GPU-master/TP1_image/CUDA/build + +//Value Computed by CMake +seuillage_SOURCE_DIR:STATIC=/home/higepi/Documents/M2R_SETI/M2_SETI/A4/TP_GPU-master/TP1_image/CUDA + + +######################## +# 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/higepi/Documents/M2R_SETI/M2_SETI/A4/TP_GPU-master/TP1_image/CUDA/build +//Major version of cmake used to create the current loaded cache +CMAKE_CACHE_MAJOR_VERSION:INTERNAL=3 +//Minor version of cmake used to create the current loaded cache +CMAKE_CACHE_MINOR_VERSION:INTERNAL=16 +//Patch version of cmake used to create the current loaded cache +CMAKE_CACHE_PATCH_VERSION:INTERNAL=3 +//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE +CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1 +//Path to CMake executable. +CMAKE_COMMAND:INTERNAL=/usr/bin/cmake +//Path to cpack program executable. +CMAKE_CPACK_COMMAND:INTERNAL=/usr/bin/cpack +//Path to ctest program executable. +CMAKE_CTEST_COMMAND:INTERNAL=/usr/bin/ctest +//ADVANCED property for variable: CMAKE_CUDA_COMPILER +CMAKE_CUDA_COMPILER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CUDA_FLAGS +CMAKE_CUDA_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CUDA_FLAGS_DEBUG +CMAKE_CUDA_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CUDA_FLAGS_MINSIZEREL +CMAKE_CUDA_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CUDA_FLAGS_RELEASE +CMAKE_CUDA_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CUDA_FLAGS_RELWITHDEBINFO +CMAKE_CUDA_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_COMPILER +CMAKE_CXX_COMPILER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_COMPILER_AR +CMAKE_CXX_COMPILER_AR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_COMPILER_RANLIB +CMAKE_CXX_COMPILER_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS +CMAKE_CXX_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_DEBUG +CMAKE_CXX_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_MINSIZEREL +CMAKE_CXX_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELEASE +CMAKE_CXX_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELWITHDEBINFO +CMAKE_CXX_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_DLLTOOL +CMAKE_DLLTOOL-ADVANCED:INTERNAL=1 +//Executable file format +CMAKE_EXECUTABLE_FORMAT:INTERNAL=ELF +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS +CMAKE_EXE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_DEBUG +CMAKE_EXE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_MINSIZEREL +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELEASE +CMAKE_EXE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXPORT_COMPILE_COMMANDS +CMAKE_EXPORT_COMPILE_COMMANDS-ADVANCED:INTERNAL=1 +//Name of external makefile project generator. +CMAKE_EXTRA_GENERATOR:INTERNAL= +//Name of generator. +CMAKE_GENERATOR:INTERNAL=Unix Makefiles +//Generator instance identifier. +CMAKE_GENERATOR_INSTANCE:INTERNAL= +//Name of generator platform. +CMAKE_GENERATOR_PLATFORM:INTERNAL= +//Name of generator toolset. +CMAKE_GENERATOR_TOOLSET:INTERNAL= +//Source directory with the top level CMakeLists.txt file for this +// project +CMAKE_HOME_DIRECTORY:INTERNAL=/home/higepi/Documents/M2R_SETI/M2_SETI/A4/TP_GPU-master/TP1_image/CUDA +//Install .so files without execute permission. +CMAKE_INSTALL_SO_NO_EXE:INTERNAL=1 +//ADVANCED property for variable: CMAKE_LINKER +CMAKE_LINKER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MAKE_PROGRAM +CMAKE_MAKE_PROGRAM-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS +CMAKE_MODULE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_DEBUG +CMAKE_MODULE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELEASE +CMAKE_MODULE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_NM +CMAKE_NM-ADVANCED:INTERNAL=1 +//number of local generators +CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJCOPY +CMAKE_OBJCOPY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJDUMP +CMAKE_OBJDUMP-ADVANCED:INTERNAL=1 +//Platform information initialized +CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_RANLIB +CMAKE_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_READELF +CMAKE_READELF-ADVANCED:INTERNAL=1 +//Path to CMake installation. +CMAKE_ROOT:INTERNAL=/usr/share/cmake-3.16 +//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 +//uname command +CMAKE_UNAME:INTERNAL=/usr/bin/uname +//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE +CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1 + diff --git a/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CMakeCXXCompiler.cmake b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CMakeCXXCompiler.cmake new file mode 100644 index 0000000..278ef39 --- /dev/null +++ b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CMakeCXXCompiler.cmake @@ -0,0 +1,88 @@ +set(CMAKE_CXX_COMPILER "/usr/bin/c++") +set(CMAKE_CXX_COMPILER_ARG1 "") +set(CMAKE_CXX_COMPILER_ID "GNU") +set(CMAKE_CXX_COMPILER_VERSION "9.4.0") +set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "") +set(CMAKE_CXX_COMPILER_WRAPPER "") +set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "14") +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") +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_CXX_PLATFORM_ID "Linux") +set(CMAKE_CXX_SIMULATE_ID "") +set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "") +set(CMAKE_CXX_SIMULATE_VERSION "") + + + +set(CMAKE_AR "/usr/bin/ar") +set(CMAKE_CXX_COMPILER_AR "/usr/bin/gcc-ar-9") +set(CMAKE_RANLIB "/usr/bin/ranlib") +set(CMAKE_CXX_COMPILER_RANLIB "/usr/bin/gcc-ranlib-9") +set(CMAKE_LINKER "/usr/bin/ld") +set(CMAKE_MT "") +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_COMPILER_IS_MINGW ) +set(CMAKE_COMPILER_IS_CYGWIN ) +if(CMAKE_COMPILER_IS_CYGWIN) + set(CYGWIN 1) + set(UNIX 1) +endif() + +set(CMAKE_CXX_COMPILER_ENV_VAR "CXX") + +if(CMAKE_COMPILER_IS_MINGW) + set(MINGW 1) +endif() +set(CMAKE_CXX_COMPILER_ID_RUN 1) +set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;CPP) +set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC) + +foreach (lang 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) + +# Save compiler ABI information. +set(CMAKE_CXX_SIZEOF_DATA_PTR "8") +set(CMAKE_CXX_COMPILER_ABI "ELF") +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 "/usr/include/c++/9;/usr/include/x86_64-linux-gnu/c++/9;/usr/include/c++/9/backward;/usr/lib/gcc/x86_64-linux-gnu/9/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 "/usr/lib/gcc/x86_64-linux-gnu/9;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib") +set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "") diff --git a/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CMakeDetermineCompilerABI_CXX.bin b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CMakeDetermineCompilerABI_CXX.bin new file mode 100755 index 0000000..9cba7ec Binary files /dev/null and b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CMakeDetermineCompilerABI_CXX.bin differ diff --git a/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CMakeSystem.cmake b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CMakeSystem.cmake new file mode 100644 index 0000000..3d4e5ed --- /dev/null +++ b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CMakeSystem.cmake @@ -0,0 +1,15 @@ +set(CMAKE_HOST_SYSTEM "Linux-5.4.0-132-generic") +set(CMAKE_HOST_SYSTEM_NAME "Linux") +set(CMAKE_HOST_SYSTEM_VERSION "5.4.0-132-generic") +set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64") + + + +set(CMAKE_SYSTEM "Linux-5.4.0-132-generic") +set(CMAKE_SYSTEM_NAME "Linux") +set(CMAKE_SYSTEM_VERSION "5.4.0-132-generic") +set(CMAKE_SYSTEM_PROCESSOR "x86_64") + +set(CMAKE_CROSSCOMPILING "FALSE") + +set(CMAKE_SYSTEM_LOADED 1) diff --git a/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/CMakeCUDACompilerId.cu b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/CMakeCUDACompilerId.cu new file mode 100644 index 0000000..e972d9e --- /dev/null +++ b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/CMakeCUDACompilerId.cu @@ -0,0 +1,364 @@ +#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" +# 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) +# endif + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#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(__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" + +# 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 + +#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_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" + +# 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 +#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 components. */ +#ifdef 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'}; +#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 "]"; + + + + +const char* info_language_dialect_default = "INFO" ":" "dialect_default[" +#if __cplusplus > 201703L + "20" +#elif __cplusplus >= 201703L + "17" +#elif __cplusplus >= 201402L + "14" +#elif __cplusplus >= 201103L + "11" +#else + "98" +#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 + require += info_language_dialect_default[argc]; + (void)argv; + return require; +} diff --git a/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp1.ii b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp1.ii new file mode 100644 index 0000000..79c71ee --- /dev/null +++ b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp1.ii @@ -0,0 +1,19891 @@ +# 1 "CMakeCUDACompilerId.cu" +# 1 "" +# 1 "" +# 1 "/usr/include/stdc-predef.h" 1 3 4 +# 1 "" 2 +# 1 "/usr/include/cuda_runtime.h" 1 3 4 +# 61 "/usr/include/cuda_runtime.h" 3 4 +#pragma GCC diagnostic push + + +#pragma GCC diagnostic ignored "-Wunused-function" +# 83 "/usr/include/cuda_runtime.h" 3 4 +# 1 "/usr/include/crt/host_config.h" 1 3 4 +# 206 "/usr/include/crt/host_config.h" 3 4 +# 1 "/usr/include/features.h" 1 3 4 +# 461 "/usr/include/features.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4 +# 452 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 453 "/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 +# 454 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4 +# 462 "/usr/include/features.h" 2 3 4 +# 485 "/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 +# 486 "/usr/include/features.h" 2 3 4 +# 207 "/usr/include/crt/host_config.h" 2 3 4 +# 84 "/usr/include/cuda_runtime.h" 2 3 4 + + + + + + + +# 1 "/usr/include/builtin_types.h" 1 3 4 +# 56 "/usr/include/builtin_types.h" 3 4 +# 1 "/usr/include/device_types.h" 1 3 4 +# 58 "/usr/include/device_types.h" 3 4 +# 1 "/usr/include/crt/host_defines.h" 1 3 4 +# 59 "/usr/include/device_types.h" 2 3 4 + + + + + + + + +# 66 "/usr/include/device_types.h" 3 4 +enum __attribute__((device_builtin)) cudaRoundMode +{ + cudaRoundNearest, + cudaRoundZero, + cudaRoundPosInf, + cudaRoundMinInf +}; +# 57 "/usr/include/builtin_types.h" 2 3 4 + + +# 1 "/usr/include/driver_types.h" 1 3 4 +# 58 "/usr/include/driver_types.h" 3 4 +# 1 "/usr/include/crt/host_defines.h" 1 3 4 +# 59 "/usr/include/driver_types.h" 2 3 4 +# 1 "/usr/include/vector_types.h" 1 3 4 +# 64 "/usr/include/vector_types.h" 3 4 +# 1 "/usr/include/crt/host_defines.h" 1 3 4 +# 65 "/usr/include/vector_types.h" 2 3 4 +# 98 "/usr/include/vector_types.h" 3 4 +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; +}; +# 274 "/usr/include/vector_types.h" 3 4 +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; +}; +# 361 "/usr/include/vector_types.h" 3 4 +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; + + + + + + + +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)) dim3(uint3 v) : x(v.x), y(v.y), z(v.z) {} + __attribute__((host)) __attribute__((device)) operator uint3(void) { uint3 t; t.x = x; t.y = y; t.z = z; return t; } + +}; + +typedef __attribute__((device_builtin)) struct dim3 dim3; +# 60 "/usr/include/driver_types.h" 2 3 4 +# 77 "/usr/include/driver_types.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/8/include/limits.h" 1 3 4 +# 34 "/usr/lib/gcc/x86_64-linux-gnu/8/include/limits.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/8/include/syslimits.h" 1 3 4 + + + + + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/8/include/limits.h" 1 3 4 +# 194 "/usr/lib/gcc/x86_64-linux-gnu/8/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 +# 183 "/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 +# 162 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4 +# 184 "/usr/include/limits.h" 2 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/posix2_lim.h" 1 3 4 +# 188 "/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 +# 192 "/usr/include/limits.h" 2 3 4 +# 195 "/usr/lib/gcc/x86_64-linux-gnu/8/include/limits.h" 2 3 4 +# 8 "/usr/lib/gcc/x86_64-linux-gnu/8/include/syslimits.h" 2 3 4 +# 35 "/usr/lib/gcc/x86_64-linux-gnu/8/include/limits.h" 2 3 4 +# 78 "/usr/include/driver_types.h" 2 3 4 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/8/include/stddef.h" 1 3 4 +# 149 "/usr/lib/gcc/x86_64-linux-gnu/8/include/stddef.h" 3 4 +typedef long int ptrdiff_t; +# 216 "/usr/lib/gcc/x86_64-linux-gnu/8/include/stddef.h" 3 4 +typedef long unsigned int size_t; +# 426 "/usr/lib/gcc/x86_64-linux-gnu/8/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)))); +# 437 "/usr/lib/gcc/x86_64-linux-gnu/8/include/stddef.h" 3 4 +} max_align_t; + + + + + + + typedef decltype(nullptr) nullptr_t; +# 79 "/usr/include/driver_types.h" 2 3 4 +# 189 "/usr/include/driver_types.h" 3 4 +enum __attribute__((device_builtin)) cudaError +{ + + + + + + cudaSuccess = 0, + + + + + + cudaErrorInvalidValue = 1, + + + + + + cudaErrorMemoryAllocation = 2, + + + + + + cudaErrorInitializationError = 3, + + + + + + + cudaErrorCudartUnloading = 4, + + + + + + + cudaErrorProfilerDisabled = 5, + + + + + + + + cudaErrorProfilerNotInitialized = 6, + + + + + + + cudaErrorProfilerAlreadyStarted = 7, + + + + + + + cudaErrorProfilerAlreadyStopped = 8, +# 259 "/usr/include/driver_types.h" 3 4 + cudaErrorInvalidConfiguration = 9, + + + + + + cudaErrorInvalidPitchValue = 12, + + + + + + cudaErrorInvalidSymbol = 13, + + + + + + + + cudaErrorInvalidHostPointer = 16, + + + + + + + + cudaErrorInvalidDevicePointer = 17, + + + + + + cudaErrorInvalidTexture = 18, + + + + + + cudaErrorInvalidTextureBinding = 19, + + + + + + + cudaErrorInvalidChannelDescriptor = 20, + + + + + + cudaErrorInvalidMemcpyDirection = 21, +# 322 "/usr/include/driver_types.h" 3 4 + cudaErrorAddressOfConstant = 22, +# 331 "/usr/include/driver_types.h" 3 4 + cudaErrorTextureFetchFailed = 23, +# 340 "/usr/include/driver_types.h" 3 4 + cudaErrorTextureNotBound = 24, +# 349 "/usr/include/driver_types.h" 3 4 + cudaErrorSynchronizationError = 25, + + + + + + cudaErrorInvalidFilterSetting = 26, + + + + + + cudaErrorInvalidNormSetting = 27, + + + + + + + + cudaErrorMixedDeviceExecution = 28, + + + + + + + + cudaErrorNotYetImplemented = 31, +# 386 "/usr/include/driver_types.h" 3 4 + cudaErrorMemoryValueTooLarge = 32, + + + + + + + cudaErrorInsufficientDriver = 35, + + + + + + cudaErrorInvalidSurface = 37, + + + + + + cudaErrorDuplicateVariableName = 43, + + + + + + cudaErrorDuplicateTextureName = 44, + + + + + + cudaErrorDuplicateSurfaceName = 45, +# 427 "/usr/include/driver_types.h" 3 4 + cudaErrorDevicesUnavailable = 46, +# 440 "/usr/include/driver_types.h" 3 4 + cudaErrorIncompatibleDriverContext = 49, + + + + + + cudaErrorMissingConfiguration = 52, +# 455 "/usr/include/driver_types.h" 3 4 + cudaErrorPriorLaunchFailure = 53, + + + + + + + cudaErrorLaunchMaxDepthExceeded = 65, + + + + + + + + cudaErrorLaunchFileScopedTex = 66, + + + + + + + + cudaErrorLaunchFileScopedSurf = 67, +# 493 "/usr/include/driver_types.h" 3 4 + cudaErrorSyncDepthExceeded = 68, +# 505 "/usr/include/driver_types.h" 3 4 + cudaErrorLaunchPendingCountExceeded = 69, + + + + + + cudaErrorInvalidDeviceFunction = 98, + + + + + + cudaErrorNoDevice = 100, + + + + + + cudaErrorInvalidDevice = 101, + + + + + cudaErrorStartupFailure = 127, + + + + + cudaErrorInvalidKernelImage = 200, +# 543 "/usr/include/driver_types.h" 3 4 + cudaErrorDeviceUninitilialized = 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, + + + + + cudaErrorInvalidSource = 300, + + + + + cudaErrorFileNotFound = 301, + + + + + cudaErrorSharedObjectSymbolNotFound = 302, + + + + + cudaErrorSharedObjectInitFailed = 303, + + + + + cudaErrorOperatingSystem = 304, + + + + + + + cudaErrorInvalidResourceHandle = 400, + + + + + + cudaErrorIllegalState = 401, + + + + + + cudaErrorSymbolNotFound = 500, + + + + + + + + cudaErrorNotReady = 600, + + + + + + + + cudaErrorIllegalAddress = 700, +# 711 "/usr/include/driver_types.h" 3 4 + cudaErrorLaunchOutOfResources = 701, +# 722 "/usr/include/driver_types.h" 3 4 + cudaErrorLaunchTimeout = 702, + + + + + + cudaErrorLaunchIncompatibleTexturing = 703, + + + + + + + cudaErrorPeerAccessAlreadyEnabled = 704, + + + + + + + cudaErrorPeerAccessNotEnabled = 705, +# 755 "/usr/include/driver_types.h" 3 4 + cudaErrorSetOnActiveProcess = 708, + + + + + + + cudaErrorContextIsDestroyed = 709, + + + + + + + cudaErrorAssert = 710, + + + + + + + cudaErrorTooManyPeers = 711, + + + + + + cudaErrorHostMemoryAlreadyRegistered = 712, + + + + + + cudaErrorHostMemoryNotRegistered = 713, +# 797 "/usr/include/driver_types.h" 3 4 + cudaErrorHardwareStackError = 714, + + + + + + + + cudaErrorIllegalInstruction = 715, +# 814 "/usr/include/driver_types.h" 3 4 + cudaErrorMisalignedAddress = 716, +# 825 "/usr/include/driver_types.h" 3 4 + cudaErrorInvalidAddressSpace = 717, + + + + + + + + cudaErrorInvalidPc = 718, +# 844 "/usr/include/driver_types.h" 3 4 + cudaErrorLaunchFailure = 719, +# 853 "/usr/include/driver_types.h" 3 4 + cudaErrorCooperativeLaunchTooLarge = 720, + + + + + cudaErrorNotPermitted = 800, + + + + + + cudaErrorNotSupported = 801, +# 873 "/usr/include/driver_types.h" 3 4 + cudaErrorSystemNotReady = 802, + + + + + + + cudaErrorSystemDriverMismatch = 803, +# 889 "/usr/include/driver_types.h" 3 4 + cudaErrorCompatNotSupportedOnDevice = 804, + + + + + cudaErrorStreamCaptureUnsupported = 900, + + + + + + cudaErrorStreamCaptureInvalidated = 901, + + + + + + cudaErrorStreamCaptureMerge = 902, + + + + + cudaErrorStreamCaptureUnmatched = 903, + + + + + + cudaErrorStreamCaptureUnjoined = 904, + + + + + + + cudaErrorStreamCaptureIsolation = 905, + + + + + + cudaErrorStreamCaptureImplicit = 906, + + + + + + cudaErrorCapturedEvent = 907, + + + + + + + cudaErrorStreamCaptureWrongThread = 908, + + + + + cudaErrorUnknown = 999, + + + + + + + + cudaErrorApiFailureBase = 10000 +}; + + + + +enum __attribute__((device_builtin)) cudaChannelFormatKind +{ + cudaChannelFormatKindSigned = 0, + cudaChannelFormatKindUnsigned = 1, + cudaChannelFormatKindFloat = 2, + cudaChannelFormatKindNone = 3 +}; + + + + +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; + + + + +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)) 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; +}; +# 1123 "/usr/include/driver_types.h" 3 4 +typedef void ( *cudaHostFn_t)(void *userData); + + + + +struct __attribute__((device_builtin)) cudaHostNodeParams { + 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 +}; + + + + +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 +{ +# 1302 "/usr/include/driver_types.h" 3 4 + __attribute__((deprecated)) enum cudaMemoryType memoryType; + + + + + + enum cudaMemoryType type; +# 1319 "/usr/include/driver_types.h" 3 4 + int device; + + + + + + void *devicePointer; +# 1334 "/usr/include/driver_types.h" 3 4 + void *hostPointer; + + + + + + + __attribute__((deprecated)) int isManaged; +}; + + + + +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; +# 1413 "/usr/include/driver_types.h" 3 4 + int preferredShmemCarveout; +}; + + + + +enum __attribute__((device_builtin)) cudaFuncAttribute +{ + cudaFuncAttributeMaxDynamicSharedMemorySize = 8, + cudaFuncAttributePreferredSharedMemoryCarveout = 9, + 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 +}; + + + + +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 +}; + + + + +enum __attribute__((device_builtin)) cudaOutputMode +{ + cudaKeyValuePair = 0x00, + cudaCSV = 0x01 +}; + + + + +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 +}; + + + + + +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 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; +}; +# 1815 "/usr/include/driver_types.h" 3 4 +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; + + + + +enum __attribute__((device_builtin)) cudaExternalMemoryHandleType { + + + + cudaExternalMemoryHandleTypeOpaqueFd = 1, + + + + cudaExternalMemoryHandleTypeOpaqueWin32 = 2, + + + + cudaExternalMemoryHandleTypeOpaqueWin32Kmt = 3, + + + + cudaExternalMemoryHandleTypeD3D12Heap = 4, + + + + cudaExternalMemoryHandleTypeD3D12Resource = 5 +}; +# 1862 "/usr/include/driver_types.h" 3 4 +struct __attribute__((device_builtin)) cudaExternalMemoryHandleDesc { + + + + enum cudaExternalMemoryHandleType type; + union { + + + + + + int fd; +# 1885 "/usr/include/driver_types.h" 3 4 + struct { + + + + void *handle; + + + + + const void *name; + } win32; + } 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 +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreHandleDesc { + + + + enum cudaExternalSemaphoreHandleType type; + union { + + + + + int fd; +# 1999 "/usr/include/driver_types.h" 3 4 + struct { + + + + void *handle; + + + + + const void *name; + } win32; + } handle; + + + + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalParams { + union { + + + + struct { + + + + unsigned long long value; + } fence; + } params; + + + + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitParams { + union { + + + + struct { + + + + unsigned long long value; + } fence; + } params; + + + + unsigned int flags; +}; +# 2069 "/usr/include/driver_types.h" 3 4 +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)) enum cudaOutputMode cudaOutputMode_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; + + + + +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; +}; + + + + +enum __attribute__((device_builtin)) cudaGraphNodeType { + cudaGraphNodeTypeKernel = 0x00, + cudaGraphNodeTypeMemcpy = 0x01, + cudaGraphNodeTypeMemset = 0x02, + cudaGraphNodeTypeHost = 0x03, + cudaGraphNodeTypeGraph = 0x04, + cudaGraphNodeTypeEmpty = 0x05, + cudaGraphNodeTypeCount +}; + + + + +typedef struct CUgraphExec_st* cudaGraphExec_t; +# 60 "/usr/include/builtin_types.h" 2 3 4 + + +# 1 "/usr/include/surface_types.h" 1 3 4 +# 84 "/usr/include/surface_types.h" 3 4 +enum __attribute__((device_builtin)) cudaSurfaceBoundaryMode +{ + cudaBoundaryModeZero = 0, + cudaBoundaryModeClamp = 1, + cudaBoundaryModeTrap = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaSurfaceFormatMode +{ + cudaFormatModeForced = 0, + cudaFormatModeAuto = 1 +}; + + + + +struct __attribute__((device_builtin)) surfaceReference +{ + + + + struct cudaChannelFormatDesc channelDesc; +}; + + + + +typedef __attribute__((device_builtin)) unsigned long long cudaSurfaceObject_t; +# 63 "/usr/include/builtin_types.h" 2 3 4 +# 1 "/usr/include/texture_types.h" 1 3 4 +# 84 "/usr/include/texture_types.h" 3 4 +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)) textureReference +{ + + + + int normalized; + + + + enum cudaTextureFilterMode filterMode; + + + + enum cudaTextureAddressMode addressMode[3]; + + + + struct cudaChannelFormatDesc channelDesc; + + + + int sRGB; + + + + unsigned int maxAnisotropy; + + + + enum cudaTextureFilterMode mipmapFilterMode; + + + + float mipmapLevelBias; + + + + float minMipmapLevelClamp; + + + + float maxMipmapLevelClamp; + int __cudaReserved[15]; +}; + + + + +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; +}; + + + + +typedef __attribute__((device_builtin)) unsigned long long cudaTextureObject_t; +# 64 "/usr/include/builtin_types.h" 2 3 4 +# 92 "/usr/include/cuda_runtime.h" 2 3 4 +# 1 "/usr/include/library_types.h" 1 3 4 +# 54 "/usr/include/library_types.h" 3 4 +typedef enum cudaDataType_t +{ + CUDA_R_16F= 2, + CUDA_C_16F= 6, + CUDA_R_32F= 0, + CUDA_C_32F= 4, + CUDA_R_64F= 1, + CUDA_C_64F= 5, + CUDA_R_8I = 3, + CUDA_C_8I = 7, + CUDA_R_8U = 8, + CUDA_C_8U = 9, + CUDA_R_32I= 10, + CUDA_C_32I= 11, + CUDA_R_32U= 12, + CUDA_C_32U= 13 +} cudaDataType; + + +typedef enum libraryPropertyType_t +{ + MAJOR_VERSION, + MINOR_VERSION, + PATCH_LEVEL +} libraryPropertyType; +# 93 "/usr/include/cuda_runtime.h" 2 3 4 + + +# 1 "/usr/include/channel_descriptor.h" 1 3 4 +# 61 "/usr/include/channel_descriptor.h" 3 4 +# 1 "/usr/include/cuda_runtime_api.h" 1 3 4 +# 138 "/usr/include/cuda_runtime_api.h" 3 4 +# 1 "/usr/include/crt/host_defines.h" 1 3 4 +# 139 "/usr/include/cuda_runtime_api.h" 2 3 4 +# 1 "/usr/include/builtin_types.h" 1 3 4 +# 140 "/usr/include/cuda_runtime_api.h" 2 3 4 + +# 1 "/usr/include/cuda_device_runtime_api.h" 1 3 4 +# 142 "/usr/include/cuda_runtime_api.h" 2 3 4 +# 245 "/usr/include/cuda_runtime_api.h" 3 4 +extern "C" { +# 280 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaDeviceReset(void); +# 301 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceSynchronize(void); +# 386 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaDeviceSetLimit(enum cudaLimit limit, size_t value); +# 420 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetLimit(size_t *pValue, enum cudaLimit limit); +# 453 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetCacheConfig(enum cudaFuncCache *pCacheConfig); +# 490 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority); +# 534 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaDeviceSetCacheConfig(enum cudaFuncCache cacheConfig); +# 565 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetSharedMemConfig(enum cudaSharedMemConfig *pConfig); +# 609 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaDeviceSetSharedMemConfig(enum cudaSharedMemConfig config); +# 636 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaDeviceGetByPCIBusId(int *device, const char *pciBusId); +# 666 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaDeviceGetPCIBusId(char *pciBusId, int len, int device); +# 713 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t *handle, cudaEvent_t event); +# 753 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaIpcOpenEventHandle(cudaEvent_t *event, cudaIpcEventHandle_t handle); +# 796 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t *handle, void *devPtr); +# 854 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaIpcOpenMemHandle(void **devPtr, cudaIpcMemHandle_t handle, unsigned int flags); +# 889 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaIpcCloseMemHandle(void *devPtr); +# 931 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadExit(void); +# 957 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSynchronize(void); +# 1006 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSetLimit(enum cudaLimit limit, size_t value); +# 1039 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadGetLimit(size_t *pValue, enum cudaLimit limit); +# 1075 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadGetCacheConfig(enum cudaFuncCache *pCacheConfig); +# 1122 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSetCacheConfig(enum cudaFuncCache cacheConfig); +# 1181 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetLastError(void); +# 1227 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaPeekAtLastError(void); +# 1243 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorName(cudaError_t error); +# 1259 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorString(cudaError_t error); +# 1288 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceCount(int *count); +# 1559 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceProperties(struct cudaDeviceProp *prop, int device); +# 1748 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device); +# 1788 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetP2PAttribute(int *value, enum cudaDeviceP2PAttr attr, int srcDevice, int dstDevice); +# 1809 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaChooseDevice(int *device, const struct cudaDeviceProp *prop); +# 1846 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaSetDevice(int device); +# 1867 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDevice(int *device); +# 1898 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaSetValidDevices(int *device_arr, int len); +# 1967 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaSetDeviceFlags( unsigned int flags ); +# 2013 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGetDeviceFlags( unsigned int *flags ); +# 2053 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaStreamCreate(cudaStream_t *pStream); +# 2085 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags); +# 2131 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithPriority(cudaStream_t *pStream, unsigned int flags, int priority); +# 2158 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int *priority); +# 2183 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int *flags); +# 2214 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamDestroy(cudaStream_t stream); +# 2240 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags); + + + + + + + +typedef void ( *cudaStreamCallback_t)(cudaStream_t stream, cudaError_t status, void *userData); +# 2315 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaStreamAddCallback(cudaStream_t stream, + cudaStreamCallback_t callback, void *userData, unsigned int flags); +# 2339 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaStreamSynchronize(cudaStream_t stream); +# 2364 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaStreamQuery(cudaStream_t stream); +# 2447 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void *devPtr, size_t length = 0, unsigned int flags = 0x04); +# 2483 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaStreamBeginCapture(cudaStream_t stream, enum cudaStreamCaptureMode mode); +# 2534 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaThreadExchangeStreamCaptureMode(enum cudaStreamCaptureMode *mode); +# 2562 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t *pGraph); +# 2600 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaStreamIsCapturing(cudaStream_t stream, enum cudaStreamCaptureStatus *pCaptureStatus); +# 2628 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaStreamGetCaptureInfo(cudaStream_t stream, enum cudaStreamCaptureStatus *pCaptureStatus, unsigned long long *pId); +# 2666 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaEventCreate(cudaEvent_t *event); +# 2703 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventCreateWithFlags(cudaEvent_t *event, unsigned int flags); +# 2742 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream = 0); +# 2773 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaEventQuery(cudaEvent_t event); +# 2803 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaEventSynchronize(cudaEvent_t event); +# 2830 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventDestroy(cudaEvent_t event); +# 2873 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaEventElapsedTime(float *ms, cudaEvent_t start, cudaEvent_t end); +# 3012 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaImportExternalMemory(cudaExternalMemory_t *extMem_out, const struct cudaExternalMemoryHandleDesc *memHandleDesc); +# 3066 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaExternalMemoryGetMappedBuffer(void **devPtr, cudaExternalMemory_t extMem, const struct cudaExternalMemoryBufferDesc *bufferDesc); +# 3121 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t *mipmap, cudaExternalMemory_t extMem, const struct cudaExternalMemoryMipmappedArrayDesc *mipmapDesc); +# 3144 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem); +# 3238 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t *extSem_out, const struct cudaExternalSemaphoreHandleDesc *semHandleDesc); +# 3277 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t *extSemArray, const struct cudaExternalSemaphoreSignalParams *paramsArray, unsigned int numExtSems, cudaStream_t stream = 0); +# 3320 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t *extSemArray, const struct cudaExternalSemaphoreWaitParams *paramsArray, unsigned int numExtSems, cudaStream_t stream = 0); +# 3342 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem); +# 3407 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaLaunchKernel(const void *func, dim3 gridDim, dim3 blockDim, void **args, size_t sharedMem, cudaStream_t stream); +# 3464 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaLaunchCooperativeKernel(const void *func, dim3 gridDim, dim3 blockDim, void **args, size_t sharedMem, cudaStream_t stream); +# 3563 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaLaunchCooperativeKernelMultiDevice(struct cudaLaunchParams *launchParamsList, unsigned int numDevices, unsigned int flags = 0); +# 3612 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaFuncSetCacheConfig(const void *func, enum cudaFuncCache cacheConfig); +# 3667 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaFuncSetSharedMemConfig(const void *func, enum cudaSharedMemConfig config); +# 3702 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetAttributes(struct cudaFuncAttributes *attr, const void *func); +# 3741 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncSetAttribute(const void *func, enum cudaFuncAttribute attr, int value); +# 3765 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaSetDoubleForDevice(double *d); +# 3789 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaSetDoubleForHost(double *d); +# 3855 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void *userData); +# 3910 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func, int blockSize, size_t dynamicSMemSize); +# 3954 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *func, int blockSize, size_t dynamicSMemSize, unsigned int flags); +# 4074 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMallocManaged(void **devPtr, size_t size, unsigned int flags = 0x01); +# 4105 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMalloc(void **devPtr, size_t size); +# 4138 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMallocHost(void **ptr, size_t size); +# 4181 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMallocPitch(void **devPtr, size_t *pitch, size_t width, size_t height); +# 4227 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMallocArray(cudaArray_t *array, const struct cudaChannelFormatDesc *desc, size_t width, size_t height = 0, unsigned int flags = 0); +# 4256 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFree(void *devPtr); +# 4279 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaFreeHost(void *ptr); +# 4302 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaFreeArray(cudaArray_t array); +# 4325 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray); +# 4391 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaHostAlloc(void **pHost, size_t size, unsigned int flags); +# 4475 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaHostRegister(void *ptr, size_t size, unsigned int flags); +# 4498 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaHostUnregister(void *ptr); +# 4543 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaHostGetDevicePointer(void **pDevice, void *pHost, unsigned int flags); +# 4565 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaHostGetFlags(unsigned int *pFlags, void *pHost); +# 4604 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMalloc3D(struct cudaPitchedPtr* pitchedDevPtr, struct cudaExtent extent); +# 4743 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMalloc3DArray(cudaArray_t *array, const struct cudaChannelFormatDesc* desc, struct cudaExtent extent, unsigned int flags = 0); +# 4882 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t *mipmappedArray, const struct cudaChannelFormatDesc* desc, struct cudaExtent extent, unsigned int numLevels, unsigned int flags = 0); +# 4911 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t *levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level); +# 5016 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMemcpy3D(const struct cudaMemcpy3DParms *p); +# 5047 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMemcpy3DPeer(const struct cudaMemcpy3DPeerParms *p); +# 5165 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy3DAsync(const struct cudaMemcpy3DParms *p, cudaStream_t stream = 0); +# 5191 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMemcpy3DPeerAsync(const struct cudaMemcpy3DPeerParms *p, cudaStream_t stream = 0); +# 5213 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMemGetInfo(size_t *free, size_t *total); +# 5239 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaArrayGetInfo(struct cudaChannelFormatDesc *desc, struct cudaExtent *extent, unsigned int *flags, cudaArray_t array); +# 5282 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMemcpy(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind); +# 5317 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMemcpyPeer(void *dst, int dstDevice, const void *src, int srcDevice, size_t count); +# 5365 "/usr/include/cuda_runtime_api.h" 3 4 +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); +# 5414 "/usr/include/cuda_runtime_api.h" 3 4 +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); +# 5463 "/usr/include/cuda_runtime_api.h" 3 4 +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); +# 5510 "/usr/include/cuda_runtime_api.h" 3 4 +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); +# 5553 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMemcpyToSymbol(const void *symbol, const void *src, size_t count, size_t offset = 0, enum cudaMemcpyKind kind = cudaMemcpyHostToDevice); +# 5596 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMemcpyFromSymbol(void *dst, const void *symbol, size_t count, size_t offset = 0, enum cudaMemcpyKind kind = cudaMemcpyDeviceToHost); +# 5652 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpyAsync(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 5687 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMemcpyPeerAsync(void *dst, int dstDevice, const void *src, int srcDevice, size_t count, cudaStream_t stream = 0); +# 5749 "/usr/include/cuda_runtime_api.h" 3 4 +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); +# 5806 "/usr/include/cuda_runtime_api.h" 3 4 +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); +# 5862 "/usr/include/cuda_runtime_api.h" 3 4 +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); +# 5913 "/usr/include/cuda_runtime_api.h" 3 4 +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); +# 5964 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMemcpyFromSymbolAsync(void *dst, const void *symbol, size_t count, size_t offset, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 5993 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMemset(void *devPtr, int value, size_t count); +# 6027 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMemset2D(void *devPtr, size_t pitch, int value, size_t width, size_t height); +# 6071 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMemset3D(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent); +# 6107 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemsetAsync(void *devPtr, int value, size_t count, cudaStream_t stream = 0); +# 6148 "/usr/include/cuda_runtime_api.h" 3 4 +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); +# 6199 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemset3DAsync(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream = 0); +# 6227 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGetSymbolAddress(void **devPtr, const void *symbol); +# 6254 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGetSymbolSize(size_t *size, const void *symbol); +# 6324 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMemPrefetchAsync(const void *devPtr, size_t count, int dstDevice, cudaStream_t stream = 0); +# 6440 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMemAdvise(const void *devPtr, size_t count, enum cudaMemoryAdvise advice, int device); +# 6499 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMemRangeGetAttribute(void *data, size_t dataSize, enum cudaMemRangeAttribute attribute, const void *devPtr, size_t count); +# 6538 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaMemRangeGetAttributes(void **data, size_t *dataSizes, enum cudaMemRangeAttribute *attributes, size_t numAttributes, const void *devPtr, size_t count); +# 6598 "/usr/include/cuda_runtime_api.h" 3 4 +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); +# 6640 "/usr/include/cuda_runtime_api.h" 3 4 +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); +# 6683 "/usr/include/cuda_runtime_api.h" 3 4 +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); +# 6734 "/usr/include/cuda_runtime_api.h" 3 4 +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); +# 6784 "/usr/include/cuda_runtime_api.h" 3 4 +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); +# 6950 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaPointerGetAttributes(struct cudaPointerAttributes *attributes, const void *ptr); +# 6991 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaDeviceCanAccessPeer(int *canAccessPeer, int device, int peerDevice); +# 7033 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags); +# 7055 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaDeviceDisablePeerAccess(int peerDevice); +# 7118 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource); +# 7153 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags); +# 7192 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0); +# 7227 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0); +# 7259 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedPointer(void **devPtr, size_t *size, cudaGraphicsResource_t resource); +# 7297 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t *array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel); +# 7326 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t *mipmappedArray, cudaGraphicsResource_t resource); +# 7397 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaBindTexture(size_t *offset, const struct textureReference *texref, const void *devPtr, const struct cudaChannelFormatDesc *desc, size_t size = (0x7fffffff * 2U + 1U)); +# 7456 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaBindTexture2D(size_t *offset, const struct textureReference *texref, const void *devPtr, const struct cudaChannelFormatDesc *desc, size_t width, size_t height, size_t pitch); +# 7494 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaBindTextureToArray(const struct textureReference *texref, cudaArray_const_t array, const struct cudaChannelFormatDesc *desc); +# 7534 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaBindTextureToMipmappedArray(const struct textureReference *texref, cudaMipmappedArray_const_t mipmappedArray, const struct cudaChannelFormatDesc *desc); +# 7560 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaUnbindTexture(const struct textureReference *texref); +# 7589 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGetTextureAlignmentOffset(size_t *offset, const struct textureReference *texref); +# 7619 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGetTextureReference(const struct textureReference **texref, const void *symbol); +# 7664 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaBindSurfaceToArray(const struct surfaceReference *surfref, cudaArray_const_t array, const struct cudaChannelFormatDesc *desc); +# 7689 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGetSurfaceReference(const struct surfaceReference **surfref, const void *symbol); +# 7724 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGetChannelDesc(struct cudaChannelFormatDesc *desc, cudaArray_const_t array); +# 7754 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) struct cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, enum cudaChannelFormatKind f); +# 7969 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaCreateTextureObject(cudaTextureObject_t *pTexObject, const struct cudaResourceDesc *pResDesc, const struct cudaTextureDesc *pTexDesc, const struct cudaResourceViewDesc *pResViewDesc); +# 7988 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject); +# 8008 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaTextureObject_t texObject); +# 8028 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGetTextureObjectTextureDesc(struct cudaTextureDesc *pTexDesc, cudaTextureObject_t texObject); +# 8049 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceViewDesc(struct cudaResourceViewDesc *pResViewDesc, cudaTextureObject_t texObject); +# 8094 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t *pSurfObject, const struct cudaResourceDesc *pResDesc); +# 8113 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject); +# 8132 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGetSurfaceObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaSurfaceObject_t surfObject); +# 8166 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaDriverGetVersion(int *driverVersion); +# 8191 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaRuntimeGetVersion(int *runtimeVersion); +# 8238 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphCreate(cudaGraph_t *pGraph, unsigned int flags); +# 8335 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphAddKernelNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaKernelNodeParams *pNodeParams); +# 8368 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, struct cudaKernelNodeParams *pNodeParams); +# 8393 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const struct cudaKernelNodeParams *pNodeParams); +# 8437 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaMemcpy3DParms *pCopyParams); +# 8460 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, struct cudaMemcpy3DParms *pNodeParams); +# 8483 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const struct cudaMemcpy3DParms *pNodeParams); +# 8525 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphAddMemsetNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaMemsetParams *pMemsetParams); +# 8548 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, struct cudaMemsetParams *pNodeParams); +# 8571 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const struct cudaMemsetParams *pNodeParams); +# 8612 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphAddHostNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaHostNodeParams *pNodeParams); +# 8635 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, struct cudaHostNodeParams *pNodeParams); +# 8658 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const struct cudaHostNodeParams *pNodeParams); +# 8696 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphAddChildGraphNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, cudaGraph_t childGraph); +# 8720 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t *pGraph); +# 8757 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies); +# 8784 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphClone(cudaGraph_t *pGraphClone, cudaGraph_t originalGraph); +# 8812 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t *pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph); +# 8843 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, enum cudaGraphNodeType *pType); +# 8874 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t *nodes, size_t *numNodes); +# 8905 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t *pRootNodes, size_t *pNumRootNodes); +# 8939 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t *from, cudaGraphNode_t *to, size_t *numEdges); +# 8970 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t *pDependencies, size_t *pNumDependencies); +# 9002 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t *pDependentNodes, size_t *pNumDependentNodes); +# 9033 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, size_t numDependencies); +# 9064 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, size_t numDependencies); +# 9090 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node); +# 9126 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphInstantiate(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, cudaGraphNode_t *pErrorNode, char *pLogBuffer, size_t bufferSize); +# 9160 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaKernelNodeParams *pNodeParams); +# 9185 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream); +# 9206 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec); +# 9226 "/usr/include/cuda_runtime_api.h" 3 4 +extern __attribute__((host)) cudaError_t cudaGraphDestroy(cudaGraph_t graph); + + + + +extern __attribute__((host)) cudaError_t cudaGetExportTable(const void **ppExportTable, const cudaUUID_t *pExportTableId); +# 9476 "/usr/include/cuda_runtime_api.h" 3 4 +} +# 62 "/usr/include/channel_descriptor.h" 2 3 4 +# 104 "/usr/include/channel_descriptor.h" 3 4 +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); +} +# 376 "/usr/include/channel_descriptor.h" 3 4 +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); +} +# 96 "/usr/include/cuda_runtime.h" 2 3 4 + +# 1 "/usr/include/driver_functions.h" 1 3 4 +# 53 "/usr/include/driver_functions.h" 3 4 +# 1 "/usr/include/builtin_types.h" 1 3 4 +# 54 "/usr/include/driver_functions.h" 2 3 4 +# 1 "/usr/include/crt/host_defines.h" 1 3 4 +# 55 "/usr/include/driver_functions.h" 2 3 4 +# 79 "/usr/include/driver_functions.h" 3 4 +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 "/usr/include/driver_functions.h" 3 4 +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 "/usr/include/driver_functions.h" 3 4 +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; +} +# 98 "/usr/include/cuda_runtime.h" 2 3 4 + + +# 1 "/usr/include/crt/host_defines.h" 1 3 4 +# 101 "/usr/include/cuda_runtime.h" 2 3 4 +# 1 "/usr/include/vector_functions.h" 1 3 4 +# 73 "/usr/include/vector_functions.h" 3 4 +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 "/usr/include/vector_functions.hpp" 1 3 4 +# 73 "/usr/include/vector_functions.hpp" 3 4 +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; +} +# 173 "/usr/include/vector_functions.h" 2 3 4 +# 102 "/usr/include/cuda_runtime.h" 2 3 4 +# 115 "/usr/include/cuda_runtime.h" 3 4 +# 1 "/usr/include/crt/common_functions.h" 1 3 4 +# 71 "/usr/include/crt/common_functions.h" 3 4 +# 1 "/usr/include/builtin_types.h" 1 3 4 +# 72 "/usr/include/crt/common_functions.h" 2 3 4 +# 1 "/usr/include/crt/host_defines.h" 1 3 4 +# 73 "/usr/include/crt/common_functions.h" 2 3 4 + + + + +# 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 + +extern "C" { + + + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/8/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) throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern void *memmove (void *__dest, const void *__src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern void *memccpy (void *__restrict __dest, const void *__restrict __src, + int __c, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + +extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1))); + + +extern int memcmp (const void *__s1, const void *__s2, size_t __n) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + +extern "C++" +{ +extern void *memchr (void *__s, int __c, size_t __n) + throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const void *memchr (const void *__s, int __c, size_t __n) + throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 89 "/usr/include/string.h" 3 4 +} +# 99 "/usr/include/string.h" 3 4 +extern "C++" void *rawmemchr (void *__s, int __c) + throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const void *rawmemchr (const void *__s, int __c) + throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + + + +extern "C++" void *memrchr (void *__s, int __c, size_t __n) + throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const void *memrchr (const void *__s, int __c, size_t __n) + throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 122 "/usr/include/string.h" 3 4 +extern char *strcpy (char *__restrict __dest, const char *__restrict __src) + throw () __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strcat (char *__restrict __dest, const char *__restrict __src) + throw () __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncat (char *__restrict __dest, const char *__restrict __src, + size_t __n) throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcmp (const char *__s1, const char *__s2) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int strncmp (const char *__s1, const char *__s2, size_t __n) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcoll (const char *__s1, const char *__s2) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern size_t strxfrm (char *__restrict __dest, + const char *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (2))); + + + +# 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 +# 28 "/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; +# 154 "/usr/include/string.h" 2 3 4 + + +extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + + +extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n, + locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4))); + + + + + +extern char *strdup (const char *__s) + throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); + + + + + + +extern char *strndup (const char *__string, size_t __n) + throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); +# 204 "/usr/include/string.h" 3 4 +extern "C++" +{ +extern char *strchr (char *__s, int __c) + throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strchr (const char *__s, int __c) + throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 224 "/usr/include/string.h" 3 4 +} + + + + + + +extern "C++" +{ +extern char *strrchr (char *__s, int __c) + throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strrchr (const char *__s, int __c) + throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 251 "/usr/include/string.h" 3 4 +} +# 261 "/usr/include/string.h" 3 4 +extern "C++" char *strchrnul (char *__s, int __c) + throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const char *strchrnul (const char *__s, int __c) + throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 273 "/usr/include/string.h" 3 4 +extern size_t strcspn (const char *__s, const char *__reject) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern size_t strspn (const char *__s, const char *__accept) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern "C++" +{ +extern char *strpbrk (char *__s, const char *__accept) + throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strpbrk (const char *__s, const char *__accept) + throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 301 "/usr/include/string.h" 3 4 +} + + + + + + +extern "C++" +{ +extern char *strstr (char *__haystack, const char *__needle) + throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strstr (const char *__haystack, const char *__needle) + throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 328 "/usr/include/string.h" 3 4 +} + + + + + + + +extern char *strtok (char *__restrict __s, const char *__restrict __delim) + throw () __attribute__ ((__nonnull__ (2))); + + + +extern char *__strtok_r (char *__restrict __s, + const char *__restrict __delim, + char **__restrict __save_ptr) + throw () __attribute__ ((__nonnull__ (2, 3))); + +extern char *strtok_r (char *__restrict __s, const char *__restrict __delim, + char **__restrict __save_ptr) + throw () __attribute__ ((__nonnull__ (2, 3))); + + + + + +extern "C++" char *strcasestr (char *__haystack, const char *__needle) + throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern "C++" const char *strcasestr (const char *__haystack, + const char *__needle) + throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 369 "/usr/include/string.h" 3 4 +extern void *memmem (const void *__haystack, size_t __haystacklen, + const void *__needle, size_t __needlelen) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3))); + + + +extern void *__mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); +extern void *mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + +extern size_t strlen (const char *__s) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern size_t strnlen (const char *__string, size_t __maxlen) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern char *strerror (int __errnum) throw (); +# 421 "/usr/include/string.h" 3 4 +extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) + throw () __attribute__ ((__nonnull__ (2))) ; + + + + + +extern char *strerror_l (int __errnum, locale_t __l) throw (); + + + +# 1 "/usr/include/strings.h" 1 3 4 +# 23 "/usr/include/strings.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/8/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) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern void bcopy (const void *__src, void *__dest, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1))); + + + +extern "C++" +{ +extern char *index (char *__s, int __c) + throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *index (const char *__s, int __c) + throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 66 "/usr/include/strings.h" 3 4 +} + + + + + + + +extern "C++" +{ +extern char *rindex (char *__s, int __c) + throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *rindex (const char *__s, int __c) + throw () __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) throw () __attribute__ ((__const__)); + + + + + +extern int ffsl (long int __l) throw () __attribute__ ((__const__)); +__extension__ extern int ffsll (long long int __ll) + throw () __attribute__ ((__const__)); + + + +extern int strcasecmp (const char *__s1, const char *__s2) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strncasecmp (const char *__s1, const char *__s2, size_t __n) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + + + + +extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + + + +extern int strncasecmp_l (const char *__s1, const char *__s2, + size_t __n, locale_t __loc) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4))); + + +} +# 433 "/usr/include/string.h" 2 3 4 + + + +extern void explicit_bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1))); + + + +extern char *strsep (char **__restrict __stringp, + const char *__restrict __delim) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + +extern char *strsignal (int __sig) throw (); + + +extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src) + throw () __attribute__ ((__nonnull__ (1, 2))); +extern char *stpcpy (char *__restrict __dest, const char *__restrict __src) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + +extern char *__stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); +extern char *stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + +extern int strverscmp (const char *__s1, const char *__s2) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1))); + + +extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1))); + + + + + + + +extern "C++" char *basename (char *__filename) + throw () __asm ("basename") __attribute__ ((__nonnull__ (1))); +extern "C++" const char *basename (const char *__filename) + throw () __asm ("basename") __attribute__ ((__nonnull__ (1))); +# 499 "/usr/include/string.h" 3 4 +} +# 78 "/usr/include/crt/common_functions.h" 2 3 4 +# 1 "/usr/include/time.h" 1 3 4 +# 29 "/usr/include/time.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/8/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 +# 26 "/usr/include/x86_64-linux-gnu/bits/time.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 +# 29 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 + + +typedef unsigned char __u_char; +typedef unsigned short int __u_short; +typedef unsigned int __u_int; +typedef unsigned long int __u_long; + + +typedef signed char __int8_t; +typedef unsigned char __uint8_t; +typedef signed short int __int16_t; +typedef unsigned short int __uint16_t; +typedef signed int __int32_t; +typedef unsigned int __uint32_t; + +typedef signed long int __int64_t; +typedef unsigned long int __uint64_t; + + + + + + +typedef __int8_t __int_least8_t; +typedef __uint8_t __uint_least8_t; +typedef __int16_t __int_least16_t; +typedef __uint16_t __uint_least16_t; +typedef __int32_t __int_least32_t; +typedef __uint32_t __uint_least32_t; +typedef __int64_t __int_least64_t; +typedef __uint64_t __uint_least64_t; + + + +typedef long int __quad_t; +typedef unsigned long int __u_quad_t; + + + + + + + +typedef long int __intmax_t; +typedef unsigned long int __uintmax_t; +# 141 "/usr/include/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 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/x86_64-linux-gnu/bits/time.h" 2 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 +# 22 "/usr/include/x86_64-linux-gnu/bits/timex.h" 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; +}; +# 23 "/usr/include/x86_64-linux-gnu/bits/timex.h" 2 3 4 + + + +struct timex +{ + 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) throw (); + +} +# 34 "/usr/include/time.h" 2 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/clock_t.h" 1 3 4 + + + + + + +typedef __clock_t clock_t; +# 38 "/usr/include/time.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types/time_t.h" 1 3 4 + + + + + + +typedef __time_t time_t; +# 39 "/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 + + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 1 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 +# 7 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 2 3 4 + + + +struct timespec +{ + __time_t tv_sec; + + + + __syscall_slong_t tv_nsec; +# 26 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4 +}; +# 43 "/usr/include/time.h" 2 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h" 1 3 4 + + + + + + +typedef __clockid_t clockid_t; +# 47 "/usr/include/time.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types/timer_t.h" 1 3 4 + + + + + + +typedef __timer_t timer_t; +# 48 "/usr/include/time.h" 2 3 4 +# 1 "/usr/include/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; + + + + +typedef __pid_t pid_t; +# 68 "/usr/include/time.h" 3 4 +extern "C" { + + + +extern clock_t clock (void) throw (); + + +extern time_t time (time_t *__timer) throw (); + + +extern double difftime (time_t __time1, time_t __time0) + throw () __attribute__ ((__const__)); + + +extern time_t mktime (struct tm *__tp) throw (); + + + + + +extern size_t strftime (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp) throw (); + + + + +extern char *strptime (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp) + throw (); + + + + + + +extern size_t strftime_l (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp, + locale_t __loc) throw (); + + + +extern char *strptime_l (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp, + locale_t __loc) throw (); + + + + + +extern struct tm *gmtime (const time_t *__timer) throw (); + + + +extern struct tm *localtime (const time_t *__timer) throw (); + + + + +extern struct tm *gmtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) throw (); + + + +extern struct tm *localtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) throw (); + + + + +extern char *asctime (const struct tm *__tp) throw (); + + +extern char *ctime (const time_t *__timer) throw (); + + + + + + +extern char *asctime_r (const struct tm *__restrict __tp, + char *__restrict __buf) throw (); + + +extern char *ctime_r (const time_t *__restrict __timer, + char *__restrict __buf) throw (); + + + + +extern char *__tzname[2]; +extern int __daylight; +extern long int __timezone; + + + + +extern char *tzname[2]; + + + +extern void tzset (void) throw (); + + + +extern int daylight; +extern long int timezone; +# 190 "/usr/include/time.h" 3 4 +extern time_t timegm (struct tm *__tp) throw (); + + +extern time_t timelocal (struct tm *__tp) throw (); + + +extern int dysize (int __year) throw () __attribute__ ((__const__)); +# 205 "/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) throw (); + + +extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw (); + + +extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp) + throw (); + + + + + + +extern int clock_nanosleep (clockid_t __clock_id, int __flags, + const struct timespec *__req, + struct timespec *__rem); + + +extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw (); + + + + +extern int timer_create (clockid_t __clock_id, + struct sigevent *__restrict __evp, + timer_t *__restrict __timerid) throw (); + + +extern int timer_delete (timer_t __timerid) throw (); + + +extern int timer_settime (timer_t __timerid, int __flags, + const struct itimerspec *__restrict __value, + struct itimerspec *__restrict __ovalue) throw (); + + +extern int timer_gettime (timer_t __timerid, struct itimerspec *__value) + throw (); + + +extern int timer_getoverrun (timer_t __timerid) throw (); + + + + + +extern int timespec_get (struct timespec *__ts, int __base) + throw () __attribute__ ((__nonnull__ (1))); +# 274 "/usr/include/time.h" 3 4 +extern int getdate_err; +# 283 "/usr/include/time.h" 3 4 +extern struct tm *getdate (const char *__string); +# 297 "/usr/include/time.h" 3 4 +extern int getdate_r (const char *__restrict __string, + struct tm *__restrict __resbufp); + + +} +# 79 "/usr/include/crt/common_functions.h" 2 3 4 + +extern "C" +{ + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) clock_t clock(void) + + + +throw (); +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memset(void*, int, size_t) throw (); +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memcpy(void*, const void*, size_t) throw (); + +} +# 103 "/usr/include/crt/common_functions.h" 3 4 +# 1 "/usr/include/c++/8/new" 1 3 4 +# 37 "/usr/include/c++/8/new" 3 4 + +# 38 "/usr/include/c++/8/new" 3 + +# 1 "/usr/include/x86_64-linux-gnu/c++/8/bits/c++config.h" 1 3 +# 236 "/usr/include/x86_64-linux-gnu/c++/8/bits/c++config.h" 3 +namespace std +{ + typedef long unsigned int size_t; + typedef long int ptrdiff_t; + + + typedef decltype(nullptr) nullptr_t; + +} +# 258 "/usr/include/x86_64-linux-gnu/c++/8/bits/c++config.h" 3 +namespace std +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +namespace __gnu_cxx +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +# 508 "/usr/include/x86_64-linux-gnu/c++/8/bits/c++config.h" 3 +# 1 "/usr/include/x86_64-linux-gnu/c++/8/bits/os_defines.h" 1 3 +# 509 "/usr/include/x86_64-linux-gnu/c++/8/bits/c++config.h" 2 3 + + +# 1 "/usr/include/x86_64-linux-gnu/c++/8/bits/cpu_defines.h" 1 3 +# 512 "/usr/include/x86_64-linux-gnu/c++/8/bits/c++config.h" 2 3 +# 40 "/usr/include/c++/8/new" 2 3 +# 1 "/usr/include/c++/8/exception" 1 3 +# 33 "/usr/include/c++/8/exception" 3 + +# 34 "/usr/include/c++/8/exception" 3 + +#pragma GCC visibility push(default) + + +# 1 "/usr/include/c++/8/bits/exception.h" 1 3 +# 34 "/usr/include/c++/8/bits/exception.h" 3 + +# 35 "/usr/include/c++/8/bits/exception.h" 3 + +#pragma GCC visibility push(default) + + + +extern "C++" { + +namespace std +{ +# 60 "/usr/include/c++/8/bits/exception.h" 3 + class exception + { + public: + exception() noexcept { } + virtual ~exception() noexcept; + + + + virtual const char* + what() const noexcept; + }; + +} + +} + +#pragma GCC visibility pop +# 39 "/usr/include/c++/8/exception" 2 3 + +extern "C++" { + +namespace std +{ + + + class bad_exception : public exception + { + public: + bad_exception() noexcept { } + + + + virtual ~bad_exception() noexcept; + + + virtual const char* + what() const noexcept; + }; + + + typedef void (*terminate_handler) (); + + + typedef void (*unexpected_handler) (); + + + terminate_handler set_terminate(terminate_handler) noexcept; + + + + terminate_handler get_terminate() noexcept; + + + + + void terminate() noexcept __attribute__ ((__noreturn__)); + + + unexpected_handler set_unexpected(unexpected_handler) noexcept; + + + + unexpected_handler get_unexpected() noexcept; + + + + + void unexpected() __attribute__ ((__noreturn__)); +# 101 "/usr/include/c++/8/exception" 3 + + bool uncaught_exception() noexcept __attribute__ ((__pure__)); + + + + + int uncaught_exceptions() noexcept __attribute__ ((__pure__)); + + + +} + +namespace __gnu_cxx +{ + +# 133 "/usr/include/c++/8/exception" 3 + void __verbose_terminate_handler(); + + +} + +} + +#pragma GCC visibility pop + + +# 1 "/usr/include/c++/8/bits/exception_ptr.h" 1 3 +# 34 "/usr/include/c++/8/bits/exception_ptr.h" 3 +#pragma GCC visibility push(default) + + +# 1 "/usr/include/c++/8/bits/exception_defines.h" 1 3 +# 38 "/usr/include/c++/8/bits/exception_ptr.h" 2 3 +# 1 "/usr/include/c++/8/bits/cxxabi_init_exception.h" 1 3 +# 34 "/usr/include/c++/8/bits/cxxabi_init_exception.h" 3 + +# 35 "/usr/include/c++/8/bits/cxxabi_init_exception.h" 3 + +#pragma GCC visibility push(default) + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/8/include/stddef.h" 1 3 4 +# 39 "/usr/include/c++/8/bits/cxxabi_init_exception.h" 2 3 +# 50 "/usr/include/c++/8/bits/cxxabi_init_exception.h" 3 +namespace std +{ + class type_info; +} + +namespace __cxxabiv1 +{ + struct __cxa_refcounted_exception; + + extern "C" + { + + void* + __cxa_allocate_exception(size_t) noexcept; + + void + __cxa_free_exception(void*) noexcept; + + + __cxa_refcounted_exception* + __cxa_init_primary_exception(void *object, std::type_info *tinfo, + void ( *dest) (void *)) noexcept; + + } +} + + + +#pragma GCC visibility pop +# 39 "/usr/include/c++/8/bits/exception_ptr.h" 2 3 +# 1 "/usr/include/c++/8/typeinfo" 1 3 +# 32 "/usr/include/c++/8/typeinfo" 3 + +# 33 "/usr/include/c++/8/typeinfo" 3 + + + +# 1 "/usr/include/c++/8/bits/hash_bytes.h" 1 3 +# 33 "/usr/include/c++/8/bits/hash_bytes.h" 3 + +# 34 "/usr/include/c++/8/bits/hash_bytes.h" 3 + + + +namespace std +{ + + + + + + + + size_t + _Hash_bytes(const void* __ptr, size_t __len, size_t __seed); + + + + + + size_t + _Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed); + + +} +# 37 "/usr/include/c++/8/typeinfo" 2 3 + + +#pragma GCC visibility push(default) + +extern "C++" { + +namespace __cxxabiv1 +{ + class __class_type_info; +} +# 80 "/usr/include/c++/8/typeinfo" 3 +namespace std +{ + + + + + + + class type_info + { + public: + + + + + virtual ~type_info(); + + + + const char* name() const noexcept + { return __name[0] == '*' ? __name + 1 : __name; } +# 115 "/usr/include/c++/8/typeinfo" 3 + bool before(const type_info& __arg) const noexcept + { return (__name[0] == '*' && __arg.__name[0] == '*') + ? __name < __arg.__name + : __builtin_strcmp (__name, __arg.__name) < 0; } + + bool operator==(const type_info& __arg) const noexcept + { + return ((__name == __arg.__name) + || (__name[0] != '*' && + __builtin_strcmp (__name, __arg.__name) == 0)); + } +# 136 "/usr/include/c++/8/typeinfo" 3 + bool operator!=(const type_info& __arg) const noexcept + { return !operator==(__arg); } + + + size_t hash_code() const noexcept + { + + return _Hash_bytes(name(), __builtin_strlen(name()), + static_cast(0xc70f6907UL)); + + + + } + + + + virtual bool __is_pointer_p() const; + + + virtual bool __is_function_p() const; + + + + + + + + virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj, + unsigned __outer) const; + + + virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target, + void **__obj_ptr) const; + + protected: + const char *__name; + + explicit type_info(const char *__n): __name(__n) { } + + private: + + type_info& operator=(const type_info&); + type_info(const type_info&); + }; + + + + + + + + class bad_cast : public exception + { + public: + bad_cast() noexcept { } + + + + virtual ~bad_cast() noexcept; + + + virtual const char* what() const noexcept; + }; + + + + + + class bad_typeid : public exception + { + public: + bad_typeid () noexcept { } + + + + virtual ~bad_typeid() noexcept; + + + virtual const char* what() const noexcept; + }; +} + +} + +#pragma GCC visibility pop +# 40 "/usr/include/c++/8/bits/exception_ptr.h" 2 3 +# 1 "/usr/include/c++/8/new" 1 3 +# 41 "/usr/include/c++/8/bits/exception_ptr.h" 2 3 + +extern "C++" { + +namespace std +{ + class type_info; + + + + + + namespace __exception_ptr + { + class exception_ptr; + } + + using __exception_ptr::exception_ptr; + + + + + + exception_ptr current_exception() noexcept; + + template + exception_ptr make_exception_ptr(_Ex) noexcept; + + + void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__)); + + namespace __exception_ptr + { + using std::rethrow_exception; + + + + + + class exception_ptr + { + void* _M_exception_object; + + explicit exception_ptr(void* __e) noexcept; + + void _M_addref() noexcept; + void _M_release() noexcept; + + void *_M_get() const noexcept __attribute__ ((__pure__)); + + friend exception_ptr std::current_exception() noexcept; + friend void std::rethrow_exception(exception_ptr); + template + friend exception_ptr std::make_exception_ptr(_Ex) noexcept; + + public: + exception_ptr() noexcept; + + exception_ptr(const exception_ptr&) noexcept; + + + exception_ptr(nullptr_t) noexcept + : _M_exception_object(0) + { } + + exception_ptr(exception_ptr&& __o) noexcept + : _M_exception_object(__o._M_exception_object) + { __o._M_exception_object = 0; } +# 117 "/usr/include/c++/8/bits/exception_ptr.h" 3 + exception_ptr& + operator=(const exception_ptr&) noexcept; + + + exception_ptr& + operator=(exception_ptr&& __o) noexcept + { + exception_ptr(static_cast(__o)).swap(*this); + return *this; + } + + + ~exception_ptr() noexcept; + + void + swap(exception_ptr&) noexcept; +# 144 "/usr/include/c++/8/bits/exception_ptr.h" 3 + explicit operator bool() const + { return _M_exception_object; } + + + friend bool + operator==(const exception_ptr&, const exception_ptr&) + noexcept __attribute__ ((__pure__)); + + const class std::type_info* + __cxa_exception_type() const noexcept + __attribute__ ((__pure__)); + }; + + bool + operator==(const exception_ptr&, const exception_ptr&) + noexcept __attribute__ ((__pure__)); + + bool + operator!=(const exception_ptr&, const exception_ptr&) + noexcept __attribute__ ((__pure__)); + + inline void + swap(exception_ptr& __lhs, exception_ptr& __rhs) + { __lhs.swap(__rhs); } + + template + inline void + __dest_thunk(void* __x) + { static_cast<_Ex*>(__x)->~_Ex(); } + + } + + + template + exception_ptr + make_exception_ptr(_Ex __ex) noexcept + { + + void* __e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex)); + (void) __cxxabiv1::__cxa_init_primary_exception( + __e, const_cast(&typeid(__ex)), + __exception_ptr::__dest_thunk<_Ex>); + try + { + ::new (__e) _Ex(__ex); + return exception_ptr(__e); + } + catch(...) + { + __cxxabiv1::__cxa_free_exception(__e); + return current_exception(); + } +# 208 "/usr/include/c++/8/bits/exception_ptr.h" 3 + } + + +} + +} + +#pragma GCC visibility pop +# 144 "/usr/include/c++/8/exception" 2 3 +# 1 "/usr/include/c++/8/bits/nested_exception.h" 1 3 +# 33 "/usr/include/c++/8/bits/nested_exception.h" 3 +#pragma GCC visibility push(default) + + + + + + +# 1 "/usr/include/c++/8/bits/move.h" 1 3 +# 34 "/usr/include/c++/8/bits/move.h" 3 +# 1 "/usr/include/c++/8/bits/concept_check.h" 1 3 +# 33 "/usr/include/c++/8/bits/concept_check.h" 3 + +# 34 "/usr/include/c++/8/bits/concept_check.h" 3 +# 35 "/usr/include/c++/8/bits/move.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + inline constexpr _Tp* + __addressof(_Tp& __r) noexcept + { return __builtin_addressof(__r); } + + + + +} + +# 1 "/usr/include/c++/8/type_traits" 1 3 +# 32 "/usr/include/c++/8/type_traits" 3 + +# 33 "/usr/include/c++/8/type_traits" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 56 "/usr/include/c++/8/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; + + + typedef integral_constant true_type; + + + typedef integral_constant false_type; + + template + using __bool_constant = integral_constant; +# 91 "/usr/include/c++/8/type_traits" 3 + template + struct conditional; + + 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 + { }; +# 180 "/usr/include/c++/8/type_traits" 3 + template + struct __success_type + { typedef _Tp type; }; + + struct __failure_type + { }; + + + + template + struct remove_cv; + + template + struct __is_void_helper + : public false_type { }; + + template<> + struct __is_void_helper + : public true_type { }; + + + template + struct is_void + : public __is_void_helper::type>::type + { }; + + template + struct __is_integral_helper + : public false_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + template<> + struct __is_integral_helper + : public true_type { }; + + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + template<> + struct __is_integral_helper<__int128> + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; +# 312 "/usr/include/c++/8/type_traits" 3 + template + struct is_integral + : public __is_integral_helper::type>::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 { }; +# 340 "/usr/include/c++/8/type_traits" 3 + template + struct is_floating_point + : public __is_floating_point_helper::type>::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::type>::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_function; + + template + struct __is_member_object_pointer_helper + : public false_type { }; + + template + struct __is_member_object_pointer_helper<_Tp _Cp::*> + : public integral_constant::value> { }; + + + template + struct is_member_object_pointer + : public __is_member_object_pointer_helper< + typename remove_cv<_Tp>::type>::type + { }; + + template + struct __is_member_function_pointer_helper + : public false_type { }; + + template + struct __is_member_function_pointer_helper<_Tp _Cp::*> + : public integral_constant::value> { }; + + + template + struct is_member_function_pointer + : public __is_member_function_pointer_helper< + typename remove_cv<_Tp>::type>::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 false_type { }; + + template + struct is_function<_Res(_ArgTypes...) > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) & > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) && > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) & > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) && > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) const > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) const & > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) const && > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) const > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) const & > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) const && > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) volatile > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) volatile & > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) volatile && > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) volatile > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) volatile & > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) volatile && > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) const volatile > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) const volatile & > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes...) const volatile && > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) const volatile > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) const volatile & > + : public true_type { }; + + template + struct is_function<_Res(_ArgTypes......) const volatile && > + : public true_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::type>::type + { }; + + + template + struct __is_nullptr_t + : public is_null_pointer<_Tp> + { }; + + + + + 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 integral_constant::value> { }; + + 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::type>::type + { }; + + + + template + struct __is_referenceable + : public __or_, is_reference<_Tp>>::type + { }; + + template + struct __is_referenceable<_Res(_Args...) > + : public true_type + { }; + + template + struct __is_referenceable<_Res(_Args......) > + : 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 + { }; + + + template + struct is_trivially_copyable + : public integral_constant + { }; + + + template + struct is_standard_layout + : public integral_constant + { }; + + + + template + struct is_pod + : public integral_constant + { }; + + + template + struct is_literal_type + : public integral_constant + { }; + + + 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_>> + { }; +# 747 "/usr/include/c++/8/type_traits" 3 + 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_>> + { }; + + + + + + + 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 + { }; + + + + + + struct __do_is_nt_destructible_impl + { + template + static integral_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 + { }; + + + template + struct is_constructible + : public __bool_constant<__is_constructible(_Tp, _Args...)> + { }; + + + template + struct is_default_constructible + : public is_constructible<_Tp>::type + { }; + + 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<_Tp, const _Tp&> + { }; + + + template + struct is_copy_constructible + : public __is_copy_constructible_impl<_Tp> + { }; + + 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<_Tp, _Tp&&> + { }; + + + template + struct is_move_constructible + : public __is_move_constructible_impl<_Tp> + { }; + + template + struct __is_nt_default_constructible_atom + : public integral_constant + { }; + + template::value> + struct __is_nt_default_constructible_impl; + + template + struct __is_nt_default_constructible_impl<_Tp, true> + : public __and_<__is_array_known_bounds<_Tp>, + __is_nt_default_constructible_atom::type>> + { }; + + template + struct __is_nt_default_constructible_impl<_Tp, false> + : public __is_nt_default_constructible_atom<_Tp> + { }; + + + template + struct is_nothrow_default_constructible + : public __and_, + __is_nt_default_constructible_impl<_Tp>> + { }; + + template + struct __is_nt_constructible_impl + : public integral_constant()...))> + { }; + + template + struct __is_nt_constructible_impl<_Tp, _Arg> + : public integral_constant(declval<_Arg>()))> + { }; + + template + struct __is_nt_constructible_impl<_Tp> + : public is_nothrow_default_constructible<_Tp> + { }; + + + template + struct is_nothrow_constructible + : public __and_, + __is_nt_constructible_impl<_Tp, _Args...>> + { }; + + 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<_Tp, const _Tp&> + { }; + + + template + struct is_nothrow_copy_constructible + : public __is_nothrow_copy_constructible_impl<_Tp> + { }; + + 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<_Tp, _Tp&&> + { }; + + + template + struct is_nothrow_move_constructible + : public __is_nothrow_move_constructible_impl<_Tp> + { }; + + + template + struct is_assignable + : public __bool_constant<__is_assignable(_Tp, _Up)> + { }; + + 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 is_assignable<_Tp&, const _Tp&> + { }; + + + template + struct is_copy_assignable + : public __is_copy_assignable_impl<_Tp> + { }; + + 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 is_assignable<_Tp&, _Tp&&> + { }; + + + template + struct is_move_assignable + : public __is_move_assignable_impl<_Tp> + { }; + + template + struct __is_nt_assignable_impl + : public integral_constant() = declval<_Up>())> + { }; + + + template + struct is_nothrow_assignable + : public __and_, + __is_nt_assignable_impl<_Tp, _Up>> + { }; + + 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<_Tp&, const _Tp&> + { }; + + + template + struct is_nothrow_copy_assignable + : public __is_nt_copy_assignable_impl<_Tp> + { }; + + 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<_Tp&, _Tp&&> + { }; + + + template + struct is_nothrow_move_assignable + : public __is_nt_move_assignable_impl<_Tp> + { }; + + + template + struct is_trivially_constructible + : public __and_, __bool_constant< + __is_trivially_constructible(_Tp, _Args...)>>::type + { }; + + + template + struct is_trivially_default_constructible + : public is_trivially_constructible<_Tp>::type + { }; + + 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_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_, + integral_constant> + { }; + + template + struct is_trivially_copy_constructible + : public __is_trivially_copy_constructible_impl<_Tp> + { }; + + + + 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_, + integral_constant> + { }; + + template + struct is_trivially_move_constructible + : public __is_trivially_move_constructible_impl<_Tp> + { }; + + + template + struct is_trivially_assignable + : public __bool_constant<__is_trivially_assignable(_Tp, _Up)> + { }; + + + + 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 __and_, + integral_constant> + { }; + + template + struct is_trivially_copy_assignable + : public __is_trivially_copy_assignable_impl<_Tp> + { }; + + + + 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 __and_, + integral_constant> + { }; + + template + struct is_trivially_move_assignable + : public __is_trivially_move_assignable_impl<_Tp> + { }; + + + template + struct is_trivially_destructible + : public __and_, integral_constant> + { }; + + + + template + struct has_virtual_destructor + : public integral_constant + { }; + + + + + + template + struct alignment_of + : public integral_constant { }; + + + 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 false_type { }; + + template + struct is_same<_Tp, _Tp> + : public true_type { }; + + + 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; }; + + template + class __is_convertible_helper<_From, _To, false> + { + template + static void __test_aux(_To1); + + template(std::declval<_From1>()))> + static true_type + __test(int); + + template + static false_type + __test(...); + + public: + typedef decltype(__test<_From, _To>(0)) type; + }; + + + + template + struct is_convertible + : public __is_convertible_helper<_From, _To>::type + { }; + + + + + + 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 + { + typedef typename + remove_const::type>::type type; + }; + + + 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; }; +# 1548 "/usr/include/c++/8/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_unsigned_selector; + + template + class __make_unsigned_selector<_Tp, true, false> + { + typedef __make_unsigned::type> __unsignedt; + typedef typename __unsignedt::__type __unsigned_type; + typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned; + + public: + typedef typename __cv_unsigned::__type __type; + }; + + template + class __make_unsigned_selector<_Tp, false, true> + { + + typedef unsigned char __smallest; + static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest); + static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short); + static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int); + static const bool __b3 = sizeof(_Tp) <= sizeof(unsigned long); + typedef conditional<__b3, unsigned long, unsigned long long> __cond3; + typedef typename __cond3::type __cond3_type; + typedef conditional<__b2, unsigned int, __cond3_type> __cond2; + typedef typename __cond2::type __cond2_type; + typedef conditional<__b1, unsigned short, __cond2_type> __cond1; + typedef typename __cond1::type __cond1_type; + + typedef typename conditional<__b0, __smallest, __cond1_type>::type + __unsigned_type; + typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned; + + public: + typedef typename __cv_unsigned::__type __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; }; +# 1652 "/usr/include/c++/8/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_signed_selector; + + template + class __make_signed_selector<_Tp, true, false> + { + typedef __make_signed::type> __signedt; + typedef typename __signedt::__type __signed_type; + typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed; + + public: + typedef typename __cv_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 + { 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, typename remove_cv<_Tp>::type> + { }; + + + 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; + }; + }; +# 1798 "/usr/include/c++/8/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; + }; +# 1837 "/usr/include/c++/8/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 typename remove_cv<_Up>::type __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 + class reference_wrapper; + + + template + struct __strip_reference_wrapper + { + typedef _Tp __type; + }; + + template + struct __strip_reference_wrapper > + { + typedef _Tp& __type; + }; + + template + struct __decay_and_strip + { + typedef typename __strip_reference_wrapper< + typename decay<_Tp>::type>::__type __type; + }; + + + + + template + struct enable_if + { }; + + + template + struct enable_if + { typedef _Tp type; }; + + template + using _Require = typename enable_if<__and_<_Cond...>::value>::type; + + + + template + struct conditional + { typedef _Iftrue type; }; + + + template + struct conditional + { typedef _Iffalse type; }; + + + template + struct common_type; + + + + struct __do_common_type_impl + { + template + static __success_type() + : std::declval<_Up>())>::type> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __common_type_impl + : private __do_common_type_impl + { + typedef decltype(_S_test<_Tp, _Up>(0)) type; + }; + + struct __do_member_type_wrapper + { + template + static __success_type _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __member_type_wrapper + : private __do_member_type_wrapper + { + typedef decltype(_S_test<_Tp>(0)) type; + }; + + template + struct __expanded_common_type_wrapper + { + typedef common_type type; + }; + + template + struct __expanded_common_type_wrapper<__failure_type, _Args...> + { typedef __failure_type type; }; + + template<> + struct common_type<> + { }; + + template + struct common_type<_Tp> + : common_type<_Tp, _Tp> + { }; + + template + struct common_type<_Tp, _Up> + : public __common_type_impl<_Tp, _Up>::type + { }; + + template + struct common_type<_Tp, _Up, _Vp...> + : public __expanded_common_type_wrapper>::type, _Vp...>::type + { }; + + + template + struct underlying_type + { + typedef __underlying_type(_Tp) type; + }; + + 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); + } +# 2035 "/usr/include/c++/8/type_traits" 3 + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + + + template + class 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 typename remove_cv::type>::type _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_cv::type>::type _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename conditional<__or_, + is_base_of<_Class, _Argval>>::value, + __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, + __result_of_memfun_deref<_MemPtr, _Arg, _Args...> + >::type::type type; + }; + + + + + + + template::type> + 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::type, + typename __inv_unwrap<_Arg>::type> + { }; + + template + struct __result_of_impl + : public __result_of_memfun::type, + 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 __enable_if_t = typename enable_if<_Cond, _Tp>::type; + + + template using __void_t = void; + + + + + 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; +# 2371 "/usr/include/c++/8/type_traits" 3 + template + struct __is_swappable; + + template + struct __is_nothrow_swappable; + + template + class tuple; + + 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::type>::type>::type + { }; + + template + inline + typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>>::value>::type + swap(_Tp&, _Tp&) + noexcept(__and_, + is_nothrow_move_assignable<_Tp>>::value); + + template + inline + typename enable_if<__is_swappable<_Tp>::value>::type + 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 + { }; + + + template + struct is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { }; + + + + template + constexpr bool is_swappable_v = + is_swappable<_Tp>::value; + + + template + 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 + { }; + + + template + struct is_nothrow_swappable_with + : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type + { }; + + + + template + constexpr bool is_swappable_with_v = + is_swappable_with<_Tp, _Up>::value; + + + template + constexpr bool is_nothrow_swappable_with_v = + is_nothrow_swappable_with<_Tp, _Up>::value; + + + + + + + template + struct __is_invocable_impl : false_type { }; + + template + struct __is_invocable_impl<_Result, _Ret, __void_t> + : __or_, is_convertible>::type + { }; + + 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 + { }; + + struct __nonesuch { + __nonesuch() = delete; + ~__nonesuch() = delete; + __nonesuch(__nonesuch const&) = delete; + void operator=(__nonesuch const&) = delete; + }; +# 2936 "/usr/include/c++/8/type_traits" 3 + +} +# 56 "/usr/include/c++/8/bits/move.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 72 "/usr/include/c++/8/bits/move.h" 3 + template + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Tp&&>(__t); } + + + + + + + + template + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type&& __t) noexcept + { + static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument" + " substituting _Tp is an lvalue reference type"); + return static_cast<_Tp&&>(__t); + } + + + + + + + template + 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 { }; +# 116 "/usr/include/c++/8/bits/move.h" 3 + template + constexpr typename + conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type + move_if_noexcept(_Tp& __x) noexcept + { return std::move(__x); } +# 136 "/usr/include/c++/8/bits/move.h" 3 + template + inline _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; + } +# 176 "/usr/include/c++/8/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]); + } + + + +} +# 41 "/usr/include/c++/8/bits/nested_exception.h" 2 3 + +extern "C++" { + +namespace std +{ + + + + + + + class nested_exception + { + exception_ptr _M_ptr; + + public: + nested_exception() noexcept : _M_ptr(current_exception()) { } + + nested_exception(const nested_exception&) noexcept = default; + + nested_exception& operator=(const nested_exception&) noexcept = default; + + virtual ~nested_exception() noexcept; + + [[noreturn]] + void + rethrow_nested() const + { + if (_M_ptr) + rethrow_exception(_M_ptr); + std::terminate(); + } + + exception_ptr + nested_ptr() const noexcept + { return _M_ptr; } + }; + + template + struct _Nested_exception : public _Except, public nested_exception + { + explicit _Nested_exception(const _Except& __ex) + : _Except(__ex) + { } + + explicit _Nested_exception(_Except&& __ex) + : _Except(static_cast<_Except&&>(__ex)) + { } + }; + + + + + template + [[noreturn]] + inline void + __throw_with_nested_impl(_Tp&& __t, true_type) + { + using _Up = typename remove_reference<_Tp>::type; + throw _Nested_exception<_Up>{std::forward<_Tp>(__t)}; + } + + template + [[noreturn]] + inline void + __throw_with_nested_impl(_Tp&& __t, false_type) + { throw std::forward<_Tp>(__t); } + + + + template + [[noreturn]] + inline void + throw_with_nested(_Tp&& __t) + { + using _Up = typename decay<_Tp>::type; + using _CopyConstructible + = __and_, is_move_constructible<_Up>>; + static_assert(_CopyConstructible::value, + "throw_with_nested argument must be CopyConstructible"); + using __nest = __and_, __bool_constant, + __not_>>; + std::__throw_with_nested_impl(std::forward<_Tp>(__t), __nest{}); + } + + + template + using __rethrow_if_nested_cond = typename enable_if< + __and_, + __or_<__not_>, + is_convertible<_Tp*, nested_exception*>>>::value + >::type; + + + template + inline __rethrow_if_nested_cond<_Ex> + __rethrow_if_nested_impl(const _Ex* __ptr) + { + if (auto __ne_ptr = dynamic_cast(__ptr)) + __ne_ptr->rethrow_nested(); + } + + + inline void + __rethrow_if_nested_impl(const void*) + { } + + + template + inline void + rethrow_if_nested(const _Ex& __ex) + { std::__rethrow_if_nested_impl(std::__addressof(__ex)); } + + +} + +} + + + +#pragma GCC visibility pop +# 145 "/usr/include/c++/8/exception" 2 3 +# 41 "/usr/include/c++/8/new" 2 3 + +#pragma GCC visibility push(default) + +extern "C++" { + +namespace std +{ + + + + + + + class bad_alloc : public exception + { + public: + bad_alloc() throw() { } + + + + 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(); + }; + + + + + + + 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; + +} +# 120 "/usr/include/c++/8/new" 3 +void* operator new(std::size_t) + __attribute__((__externally_visible__)); +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__)); + +void* operator new(std::size_t, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); +void* operator new[](std::size_t, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); +void operator delete(void*, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); +void operator delete[](void*, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); +# 168 "/usr/include/c++/8/new" 3 +inline void* operator new(std::size_t, void* __p) noexcept +{ return __p; } +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 { } + +} +# 216 "/usr/include/c++/8/new" 3 +#pragma GCC visibility pop +# 104 "/usr/include/crt/common_functions.h" 2 3 4 +# 117 "/usr/include/crt/common_functions.h" 3 4 +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 + +extern "C" { + + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/8/include/stddef.h" 1 3 4 +# 34 "/usr/include/stdio.h" 2 3 4 + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/8/include/stdarg.h" 1 3 4 +# 40 "/usr/lib/gcc/x86_64-linux-gnu/8/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; +# 63 "/usr/include/stdio.h" 3 4 +typedef __off_t off_t; + + + + + + +typedef __off64_t off64_t; + + + + + + +typedef __ssize_t ssize_t; + + + + + + +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 + + + +extern FILE *stdin; +extern FILE *stdout; +extern FILE *stderr; + + + + + + +extern int remove (const char *__filename) throw (); + +extern int rename (const char *__old, const char *__new) throw (); + + + +extern int renameat (int __oldfd, const char *__old, int __newfd, + const char *__new) throw (); +# 164 "/usr/include/stdio.h" 3 4 +extern int renameat2 (int __oldfd, const char *__old, int __newfd, + const char *__new, unsigned int __flags) throw (); + + + + + + + +extern FILE *tmpfile (void) ; +# 183 "/usr/include/stdio.h" 3 4 +extern FILE *tmpfile64 (void) ; + + + +extern char *tmpnam (char *__s) throw () ; + + + + +extern char *tmpnam_r (char *__s) throw () ; +# 204 "/usr/include/stdio.h" 3 4 +extern char *tempnam (const char *__dir, const char *__pfx) + throw () __attribute__ ((__malloc__)) ; + + + + + + + +extern int fclose (FILE *__stream); + + + + +extern int fflush (FILE *__stream); +# 227 "/usr/include/stdio.h" 3 4 +extern int fflush_unlocked (FILE *__stream); +# 237 "/usr/include/stdio.h" 3 4 +extern int fcloseall (void); +# 246 "/usr/include/stdio.h" 3 4 +extern FILE *fopen (const char *__restrict __filename, + const char *__restrict __modes) ; + + + + +extern FILE *freopen (const char *__restrict __filename, + const char *__restrict __modes, + FILE *__restrict __stream) ; +# 270 "/usr/include/stdio.h" 3 4 +extern FILE *fopen64 (const char *__restrict __filename, + const char *__restrict __modes) ; +extern FILE *freopen64 (const char *__restrict __filename, + const char *__restrict __modes, + FILE *__restrict __stream) ; + + + + +extern FILE *fdopen (int __fd, const char *__modes) throw () ; + + + + + +extern FILE *fopencookie (void *__restrict __magic_cookie, + const char *__restrict __modes, + cookie_io_functions_t __io_funcs) throw () ; + + + + +extern FILE *fmemopen (void *__s, size_t __len, const char *__modes) + throw () ; + + + + +extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ; + + + + + +extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw (); + + + +extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, + int __modes, size_t __n) throw (); + + + + +extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, + size_t __size) throw (); + + +extern void setlinebuf (FILE *__stream) throw (); + + + + + + + +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, ...) throw (); + + + + + +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) throw (); + + + +extern int snprintf (char *__restrict __s, size_t __maxlen, + const char *__restrict __format, ...) + throw () __attribute__ ((__format__ (__printf__, 3, 4))); + +extern int vsnprintf (char *__restrict __s, size_t __maxlen, + const char *__restrict __format, __gnuc_va_list __arg) + throw () __attribute__ ((__format__ (__printf__, 3, 0))); + + + + + +extern int vasprintf (char **__restrict __ptr, const char *__restrict __f, + __gnuc_va_list __arg) + throw () __attribute__ ((__format__ (__printf__, 2, 0))) ; +extern int __asprintf (char **__restrict __ptr, + const char *__restrict __fmt, ...) + throw () __attribute__ ((__format__ (__printf__, 2, 3))) ; +extern int asprintf (char **__restrict __ptr, + const char *__restrict __fmt, ...) + throw () __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, ...) throw (); + + + + + + +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, ...) throw () __asm__ ("" "__isoc99_sscanf") + + ; +# 432 "/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) + throw () __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) throw () __asm__ ("" "__isoc99_vsscanf") + + + + __attribute__ ((__format__ (__scanf__, 2, 0))); +# 485 "/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); +# 510 "/usr/include/stdio.h" 3 4 +extern int fgetc_unlocked (FILE *__stream); +# 521 "/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); +# 537 "/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) + ; +# 587 "/usr/include/stdio.h" 3 4 +extern char *fgets_unlocked (char *__restrict __s, int __n, + FILE *__restrict __stream) ; +# 603 "/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); +# 662 "/usr/include/stdio.h" 3 4 +extern int fputs_unlocked (const char *__restrict __s, + FILE *__restrict __stream); +# 673 "/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); +# 707 "/usr/include/stdio.h" 3 4 +extern int fseeko (FILE *__stream, __off_t __off, int __whence); + + + + +extern __off_t ftello (FILE *__stream) ; +# 731 "/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); +# 750 "/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) throw (); + +extern int feof (FILE *__stream) throw () ; + +extern int ferror (FILE *__stream) throw () ; + + + +extern void clearerr_unlocked (FILE *__stream) throw (); +extern int feof_unlocked (FILE *__stream) throw () ; +extern int ferror_unlocked (FILE *__stream) throw () ; + + + + + + + +extern void perror (const char *__s); + + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 1 3 4 +# 26 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 3 4 +extern int sys_nerr; +extern const char *const sys_errlist[]; + + +extern int _sys_nerr; +extern const char *const _sys_errlist[]; +# 782 "/usr/include/stdio.h" 2 3 4 + + + + +extern int fileno (FILE *__stream) throw () ; + + + + +extern int fileno_unlocked (FILE *__stream) throw () ; +# 800 "/usr/include/stdio.h" 3 4 +extern FILE *popen (const char *__command, const char *__modes) ; + + + + + +extern int pclose (FILE *__stream); + + + + + +extern char *ctermid (char *__s) throw (); + + + + + +extern char *cuserid (char *__s); + + + + +struct obstack; + + +extern int obstack_printf (struct obstack *__restrict __obstack, + const char *__restrict __format, ...) + throw () __attribute__ ((__format__ (__printf__, 2, 3))); +extern int obstack_vprintf (struct obstack *__restrict __obstack, + const char *__restrict __format, + __gnuc_va_list __args) + throw () __attribute__ ((__format__ (__printf__, 2, 0))); + + + + + + + +extern void flockfile (FILE *__stream) throw (); + + + +extern int ftrylockfile (FILE *__stream) throw () ; + + +extern void funlockfile (FILE *__stream) throw (); +# 858 "/usr/include/stdio.h" 3 4 +extern int __uflow (FILE *); +extern int __overflow (FILE *, int); +# 873 "/usr/include/stdio.h" 3 4 +} +# 129 "/usr/include/crt/common_functions.h" 2 3 4 +# 1 "/usr/include/c++/8/stdlib.h" 1 3 4 +# 36 "/usr/include/c++/8/stdlib.h" 3 4 +# 1 "/usr/include/c++/8/cstdlib" 1 3 4 +# 39 "/usr/include/c++/8/cstdlib" 3 4 + +# 40 "/usr/include/c++/8/cstdlib" 3 +# 75 "/usr/include/c++/8/cstdlib" 3 +# 1 "/usr/include/stdlib.h" 1 3 4 +# 25 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4 +# 26 "/usr/include/stdlib.h" 2 3 4 + + + + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/8/include/stddef.h" 1 3 4 +# 32 "/usr/include/stdlib.h" 2 3 4 + +extern "C" { + + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 1 3 4 +# 52 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 3 4 +typedef enum +{ + P_ALL, + P_PID, + P_PGID +} idtype_t; +# 40 "/usr/include/stdlib.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 1 3 4 +# 41 "/usr/include/stdlib.h" 2 3 4 +# 55 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 1 3 4 +# 120 "/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; +# 121 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 2 3 4 +# 56 "/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; +# 97 "/usr/include/stdlib.h" 3 4 +extern size_t __ctype_get_mb_cur_max (void) throw () ; + + + +extern double atof (const char *__nptr) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern int atoi (const char *__nptr) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern long int atol (const char *__nptr) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +__extension__ extern long long int atoll (const char *__nptr) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +extern double strtod (const char *__restrict __nptr, + char **__restrict __endptr) + throw () __attribute__ ((__nonnull__ (1))); + + + +extern float strtof (const char *__restrict __nptr, + char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1))); + +extern long double strtold (const char *__restrict __nptr, + char **__restrict __endptr) + throw () __attribute__ ((__nonnull__ (1))); +# 140 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32 (const char *__restrict __nptr, + char **__restrict __endptr) + throw () __attribute__ ((__nonnull__ (1))); + + + +extern _Float64 strtof64 (const char *__restrict __nptr, + char **__restrict __endptr) + throw () __attribute__ ((__nonnull__ (1))); +# 158 "/usr/include/stdlib.h" 3 4 +extern _Float32x strtof32x (const char *__restrict __nptr, + char **__restrict __endptr) + throw () __attribute__ ((__nonnull__ (1))); + + + +extern _Float64x strtof64x (const char *__restrict __nptr, + char **__restrict __endptr) + throw () __attribute__ ((__nonnull__ (1))); +# 176 "/usr/include/stdlib.h" 3 4 +extern long int strtol (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + throw () __attribute__ ((__nonnull__ (1))); + +extern unsigned long int strtoul (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + throw () __attribute__ ((__nonnull__ (1))); + + + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + throw () __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + throw () __attribute__ ((__nonnull__ (1))); + + + + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + throw () __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + throw () __attribute__ ((__nonnull__ (1))); + + + + +extern int strfromd (char *__dest, size_t __size, const char *__format, + double __f) + throw () __attribute__ ((__nonnull__ (3))); + +extern int strfromf (char *__dest, size_t __size, const char *__format, + float __f) + throw () __attribute__ ((__nonnull__ (3))); + +extern int strfroml (char *__dest, size_t __size, const char *__format, + long double __f) + throw () __attribute__ ((__nonnull__ (3))); +# 232 "/usr/include/stdlib.h" 3 4 +extern int strfromf32 (char *__dest, size_t __size, const char * __format, + _Float32 __f) + throw () __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64 (char *__dest, size_t __size, const char * __format, + _Float64 __f) + throw () __attribute__ ((__nonnull__ (3))); +# 250 "/usr/include/stdlib.h" 3 4 +extern int strfromf32x (char *__dest, size_t __size, const char * __format, + _Float32x __f) + throw () __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64x (char *__dest, size_t __size, const char * __format, + _Float64x __f) + throw () __attribute__ ((__nonnull__ (3))); +# 274 "/usr/include/stdlib.h" 3 4 +extern long int strtol_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4))); + +extern unsigned long int strtoul_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 4))); + +extern double strtod_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 3))); + +extern float strtof_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 3))); + +extern long double strtold_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 3))); +# 316 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64 strtof64_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 3))); +# 337 "/usr/include/stdlib.h" 3 4 +extern _Float32x strtof32x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64x strtof64x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 3))); +# 385 "/usr/include/stdlib.h" 3 4 +extern char *l64a (long int __n) throw () ; + + +extern long int a64l (const char *__s) + throw () __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; +# 103 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 +typedef __id_t id_t; +# 114 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 +typedef __daddr_t daddr_t; +typedef __caddr_t caddr_t; + + + + + +typedef __key_t key_t; +# 134 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 +typedef __useconds_t useconds_t; + + + +typedef __suseconds_t suseconds_t; + + + + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/8/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 +# 22 "/usr/include/x86_64-linux-gnu/bits/select.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 23 "/usr/include/x86_64-linux-gnu/bits/select.h" 2 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 +# 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" { +# 101 "/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); +# 113 "/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); +# 126 "/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 + + + + +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; +# 74 "/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 +}; +# 75 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4 +# 87 "/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 +}; +# 88 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4 + + + + +struct __pthread_cond_s +{ + __extension__ union + { + __extension__ unsigned long long int __wseq; + struct + { + unsigned int __low; + unsigned int __high; + } __wseq32; + }; + __extension__ union + { + __extension__ unsigned long long int __g1_start; + struct + { + unsigned int __low; + unsigned int __high; + } __g1_start32; + }; + unsigned int __g_refs[2] ; + unsigned int __g_size[2]; + unsigned int __g1_orig_size; + unsigned int __wrefs; + unsigned int __g_signals[2]; +}; +# 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 + + +} +# 395 "/usr/include/stdlib.h" 2 3 4 + + + + + + +extern long int random (void) throw (); + + +extern void srandom (unsigned int __seed) throw (); + + + + + +extern char *initstate (unsigned int __seed, char *__statebuf, + size_t __statelen) throw () __attribute__ ((__nonnull__ (2))); + + + +extern char *setstate (char *__statebuf) throw () __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) throw () __attribute__ ((__nonnull__ (1, 2))); + +extern int srandom_r (unsigned int __seed, struct random_data *__buf) + throw () __attribute__ ((__nonnull__ (2))); + +extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, + size_t __statelen, + struct random_data *__restrict __buf) + throw () __attribute__ ((__nonnull__ (2, 4))); + +extern int setstate_r (char *__restrict __statebuf, + struct random_data *__restrict __buf) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern int rand (void) throw (); + +extern void srand (unsigned int __seed) throw (); + + + +extern int rand_r (unsigned int *__seed) throw (); + + + + + + + +extern double drand48 (void) throw (); +extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1))); + + +extern long int lrand48 (void) throw (); +extern long int nrand48 (unsigned short int __xsubi[3]) + throw () __attribute__ ((__nonnull__ (1))); + + +extern long int mrand48 (void) throw (); +extern long int jrand48 (unsigned short int __xsubi[3]) + throw () __attribute__ ((__nonnull__ (1))); + + +extern void srand48 (long int __seedval) throw (); +extern unsigned short int *seed48 (unsigned short int __seed16v[3]) + throw () __attribute__ ((__nonnull__ (1))); +extern void lcong48 (unsigned short int __param[7]) throw () __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) throw () __attribute__ ((__nonnull__ (1, 2))); +extern int erand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int lrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + throw () __attribute__ ((__nonnull__ (1, 2))); +extern int nrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int mrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + throw () __attribute__ ((__nonnull__ (1, 2))); +extern int jrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int srand48_r (long int __seedval, struct drand48_data *__buffer) + throw () __attribute__ ((__nonnull__ (2))); + +extern int seed48_r (unsigned short int __seed16v[3], + struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2))); + +extern int lcong48_r (unsigned short int __param[7], + struct drand48_data *__buffer) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + +extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) + __attribute__ ((__alloc_size__ (1))) ; + +extern void *calloc (size_t __nmemb, size_t __size) + throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) ; + + + + + + +extern void *realloc (void *__ptr, size_t __size) + throw () __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2))); + + + + + + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + throw () __attribute__ ((__warn_unused_result__)) + __attribute__ ((__alloc_size__ (2, 3))); + + + +extern void free (void *__ptr) throw (); + + +# 1 "/usr/include/alloca.h" 1 3 4 +# 24 "/usr/include/alloca.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/8/include/stddef.h" 1 3 4 +# 25 "/usr/include/alloca.h" 2 3 4 + +extern "C" { + + + + + +extern void *alloca (size_t __size) throw (); + + + + + +} +# 569 "/usr/include/stdlib.h" 2 3 4 + + + + + +extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) + __attribute__ ((__alloc_size__ (1))) ; + + + + +extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) + throw () __attribute__ ((__nonnull__ (1))) ; + + + + +extern void *aligned_alloc (size_t __alignment, size_t __size) + throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ; + + + +extern void abort (void) throw () __attribute__ ((__noreturn__)); + + + +extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1))); + + + + +extern "C++" int at_quick_exit (void (*__func) (void)) + throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1))); +# 610 "/usr/include/stdlib.h" 3 4 +extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) + throw () __attribute__ ((__nonnull__ (1))); + + + + + +extern void exit (int __status) throw () __attribute__ ((__noreturn__)); + + + + + +extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__)); + + + + + +extern void _Exit (int __status) throw () __attribute__ ((__noreturn__)); + + + + +extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ; + + + + +extern char *secure_getenv (const char *__name) + throw () __attribute__ ((__nonnull__ (1))) ; + + + + + + +extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1))); + + + + + +extern int setenv (const char *__name, const char *__value, int __replace) + throw () __attribute__ ((__nonnull__ (2))); + + +extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))); + + + + + + +extern int clearenv (void) throw (); +# 675 "/usr/include/stdlib.h" 3 4 +extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1))); +# 688 "/usr/include/stdlib.h" 3 4 +extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 698 "/usr/include/stdlib.h" 3 4 +extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 710 "/usr/include/stdlib.h" 3 4 +extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; +# 720 "/usr/include/stdlib.h" 3 4 +extern int mkstemps64 (char *__template, int __suffixlen) + __attribute__ ((__nonnull__ (1))) ; +# 731 "/usr/include/stdlib.h" 3 4 +extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ; +# 742 "/usr/include/stdlib.h" 3 4 +extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 752 "/usr/include/stdlib.h" 3 4 +extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 762 "/usr/include/stdlib.h" 3 4 +extern int mkostemps (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 774 "/usr/include/stdlib.h" 3 4 +extern int mkostemps64 (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 784 "/usr/include/stdlib.h" 3 4 +extern int system (const char *__command) ; + + + + + +extern char *canonicalize_file_name (const char *__name) + throw () __attribute__ ((__nonnull__ (1))) ; +# 800 "/usr/include/stdlib.h" 3 4 +extern char *realpath (const char *__restrict __name, + char *__restrict __resolved) throw () ; + + + + + + +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) throw () __attribute__ ((__const__)) ; +extern long int labs (long int __x) throw () __attribute__ ((__const__)) ; + + +__extension__ extern long long int llabs (long long int __x) + throw () __attribute__ ((__const__)) ; + + + + + + +extern div_t div (int __numer, int __denom) + throw () __attribute__ ((__const__)) ; +extern ldiv_t ldiv (long int __numer, long int __denom) + throw () __attribute__ ((__const__)) ; + + +__extension__ extern lldiv_t lldiv (long long int __numer, + long long int __denom) + throw () __attribute__ ((__const__)) ; +# 872 "/usr/include/stdlib.h" 3 4 +extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *gcvt (double __value, int __ndigit, char *__buf) + throw () __attribute__ ((__nonnull__ (3))) ; + + + + +extern char *qecvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + throw () __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qfcvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + throw () __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qgcvt (long double __value, int __ndigit, char *__buf) + throw () __attribute__ ((__nonnull__ (3))) ; + + + + +extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) throw () __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) throw () __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) + throw () __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) + throw () __attribute__ ((__nonnull__ (3, 4, 5))); + + + + + +extern int mblen (const char *__s, size_t __n) throw (); + + +extern int mbtowc (wchar_t *__restrict __pwc, + const char *__restrict __s, size_t __n) throw (); + + +extern int wctomb (char *__s, wchar_t __wchar) throw (); + + + +extern size_t mbstowcs (wchar_t *__restrict __pwcs, + const char *__restrict __s, size_t __n) throw (); + +extern size_t wcstombs (char *__restrict __s, + const wchar_t *__restrict __pwcs, size_t __n) + throw (); + + + + + + + +extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ; +# 957 "/usr/include/stdlib.h" 3 4 +extern int getsubopt (char **__restrict __optionp, + char *const *__restrict __tokens, + char **__restrict __valuep) + throw () __attribute__ ((__nonnull__ (1, 2, 3))) ; + + + + + + + +extern int posix_openpt (int __oflag) ; + + + + + + + +extern int grantpt (int __fd) throw (); + + + +extern int unlockpt (int __fd) throw (); + + + + +extern char *ptsname (int __fd) throw () ; + + + + + + +extern int ptsname_r (int __fd, char *__buf, size_t __buflen) + throw () __attribute__ ((__nonnull__ (2))); + + +extern int getpt (void); + + + + + + +extern int getloadavg (double __loadavg[], int __nelem) + throw () __attribute__ ((__nonnull__ (1))); +# 1013 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/stdlib-float.h" 1 3 4 +# 1014 "/usr/include/stdlib.h" 2 3 4 +# 1023 "/usr/include/stdlib.h" 3 4 +} +# 76 "/usr/include/c++/8/cstdlib" 2 3 + +# 1 "/usr/include/c++/8/bits/std_abs.h" 1 3 +# 33 "/usr/include/c++/8/bits/std_abs.h" 3 + +# 34 "/usr/include/c++/8/bits/std_abs.h" 3 +# 46 "/usr/include/c++/8/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); } + + + + + + + + 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; } +# 106 "/usr/include/c++/8/bits/std_abs.h" 3 + +} +} +# 78 "/usr/include/c++/8/cstdlib" 2 3 +# 121 "/usr/include/c++/8/cstdlib" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::div_t; + using ::ldiv_t; + + using ::abort; + + + + 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++/8/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++/8/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++/8/stdlib.h" 2 3 4 + +using std::abort; +using std::atexit; +using std::exit; + + + using std::at_quick_exit; + + + using std::quick_exit; + + + + +using std::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; +# 130 "/usr/include/crt/common_functions.h" 2 3 4 + + + + + +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) throw (); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void free(void*) throw (); + +} + + + + + +# 1 "/usr/include/assert.h" 1 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) + throw () __attribute__ ((__noreturn__)); + + +extern void __assert_perror_fail (int __errnum, const char *__file, + unsigned int __line, const char *__function) + throw () __attribute__ ((__noreturn__)); + + + + +extern void __assert (const char *__assertion, const char *__file, int __line) + throw () __attribute__ ((__noreturn__)); + + +} +# 159 "/usr/include/crt/common_functions.h" 2 3 4 + + +extern "C" +{ +# 189 "/usr/include/crt/common_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void __assert_fail( + const char *, const char *, unsigned int, const char *) + throw (); + + + + +} +# 240 "/usr/include/crt/common_functions.h" 3 4 +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(); +# 267 "/usr/include/crt/common_functions.h" 3 4 +# 1 "/usr/include/crt/math_functions.h" 1 3 4 +# 99 "/usr/include/crt/math_functions.h" 3 4 +# 1 "/usr/include/builtin_types.h" 1 3 4 +# 100 "/usr/include/crt/math_functions.h" 2 3 4 +# 1 "/usr/include/crt/host_defines.h" 1 3 4 +# 101 "/usr/include/crt/math_functions.h" 2 3 4 + + + + + + + +extern "C" +{ +# 192 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) int abs(int) throw (); +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long int labs(long int) throw (); +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long long int llabs(long long int) throw (); +# 244 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fabs(double x) throw (); +# 285 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fabsf(float x) throw (); + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int min(int, int); + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned int umin(unsigned int, unsigned int); +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llmin(long long int, long long int); +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned long long int ullmin(unsigned long long int, unsigned long long int); +# 314 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fminf(float x, float y) throw (); +# 334 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmin(double x, double y) throw (); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int max(int, int); + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned int umax(unsigned int, unsigned int); +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llmax(long long int, long long int); +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned long long int ullmax(unsigned long long int, unsigned long long int); +# 366 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaxf(float x, float y) throw (); +# 386 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmax(double, double) throw (); +# 430 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sin(double x) throw (); +# 463 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cos(double x) throw (); +# 482 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincos(double x, double *sptr, double *cptr) throw (); +# 498 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincosf(float x, float *sptr, float *cptr) throw (); +# 543 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tan(double x) throw (); +# 612 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sqrt(double x) throw (); +# 684 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rsqrt(double x); +# 754 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rsqrtf(float x); +# 810 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log2(double x) throw (); +# 835 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp2(double x) throw (); +# 860 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp2f(float x) throw (); +# 887 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp10(double x) throw (); +# 910 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp10f(float x) throw (); +# 956 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double expm1(double x) throw (); +# 1001 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expm1f(float x) throw (); +# 1056 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log2f(float x) throw (); +# 1110 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log10(double x) throw (); +# 1181 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log(double x) throw (); +# 1275 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log1p(double x) throw (); +# 1372 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log1pf(float x) throw (); +# 1447 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double floor(double x) throw (); +# 1486 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp(double x) throw (); +# 1517 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cosh(double x) throw (); +# 1547 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinh(double x) throw (); +# 1577 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tanh(double x) throw (); +# 1612 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acosh(double x) throw (); +# 1650 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acoshf(float x) throw (); +# 1666 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asinh(double x) throw (); +# 1682 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinhf(float x) throw (); +# 1736 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atanh(double x) throw (); +# 1790 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanhf(float x) throw (); +# 1849 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ldexp(double x, int exp) throw (); +# 1905 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ldexpf(float x, int exp) throw (); +# 1957 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double logb(double x) throw (); +# 2012 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logbf(float x) throw (); +# 2042 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogb(double x) throw (); +# 2072 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogbf(float x) throw (); +# 2148 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbn(double x, int n) throw (); +# 2224 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalbnf(float x, int n) throw (); +# 2300 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbln(double x, long int n) throw (); +# 2376 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalblnf(float x, long int n) throw (); +# 2454 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double frexp(double x, int *nptr) throw (); +# 2529 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float frexpf(float x, int *nptr) throw (); +# 2543 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double round(double x) throw (); +# 2560 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float roundf(float x) throw (); +# 2578 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lround(double x) throw (); +# 2596 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lroundf(float x) throw (); +# 2614 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llround(double x) throw (); +# 2632 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llroundf(float x) throw (); +# 2668 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rint(double x) throw (); +# 2684 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rintf(float x) throw (); +# 2701 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrint(double x) throw (); +# 2718 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrintf(float x) throw (); +# 2735 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrint(double x) throw (); +# 2752 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrintf(float x) throw (); +# 2805 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nearbyint(double x) throw (); +# 2858 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nearbyintf(float x) throw (); +# 2920 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ceil(double x) throw (); +# 2932 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double trunc(double x) throw (); +# 2947 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float truncf(float x) throw (); +# 2973 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fdim(double x, double y) throw (); +# 2999 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fdimf(float x, float y) throw (); +# 3035 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan2(double y, double x) throw (); +# 3066 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan(double x) throw (); +# 3089 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acos(double x) throw (); +# 3121 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asin(double x) throw (); +# 3167 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double hypot(double x, double y) throw (); +# 3219 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rhypot(double x, double y) throw (); +# 3265 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float hypotf(float x, float y) throw (); +# 3317 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rhypotf(float x, float y) throw (); +# 3361 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double norm3d(double a, double b, double c) throw (); +# 3412 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rnorm3d(double a, double b, double c) throw (); +# 3461 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double norm4d(double a, double b, double c, double d) throw (); +# 3517 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rnorm4d(double a, double b, double c, double d) throw (); +# 3562 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double norm(int dim, double const * t) throw (); +# 3613 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rnorm(int dim, double const * t) throw (); +# 3665 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rnormf(int dim, float const * a) throw (); +# 3709 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normf(int dim, float const * a) throw (); +# 3754 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float norm3df(float a, float b, float c) throw (); +# 3805 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rnorm3df(float a, float b, float c) throw (); +# 3854 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float norm4df(float a, float b, float c, float d) throw (); +# 3910 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rnorm4df(float a, float b, float c, float d) throw (); +# 3997 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cbrt(double x) throw (); +# 4083 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cbrtf(float x) throw (); +# 4138 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rcbrt(double x); +# 4188 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rcbrtf(float x); +# 4248 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinpi(double x); +# 4308 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinpif(float x); +# 4360 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cospi(double x); +# 4412 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cospif(float x); +# 4442 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospi(double x, double *sptr, double *cptr); +# 4472 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospif(float x, float *sptr, float *cptr); +# 4784 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double pow(double x, double y) throw (); +# 4840 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double modf(double x, double *iptr) throw (); +# 4899 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmod(double x, double y) throw (); +# 4985 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remainder(double x, double y) throw (); +# 5075 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remainderf(float x, float y) throw (); +# 5129 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remquo(double x, double y, int *quo) throw (); +# 5183 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remquof(float x, float y, int *quo) throw (); +# 5224 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j0(double x) throw (); +# 5266 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j0f(float x) throw (); +# 5327 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j1(double x) throw (); +# 5388 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j1f(float x) throw (); +# 5431 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double jn(int n, double x) throw (); +# 5474 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float jnf(int n, float x) throw (); +# 5526 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y0(double x) throw (); +# 5578 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y0f(float x) throw (); +# 5630 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y1(double x) throw (); +# 5682 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y1f(float x) throw (); +# 5735 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double yn(int n, double x) throw (); +# 5788 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ynf(int n, float x) throw (); +# 5815 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i0(double x) throw (); +# 5841 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i0f(float x) throw (); +# 5868 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i1(double x) throw (); +# 5894 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i1f(float x) throw (); +# 5977 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erf(double x) throw (); +# 6059 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erff(float x) throw (); +# 6123 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfinv(double y); +# 6180 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfinvf(float y); +# 6219 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfc(double x) throw (); +# 6257 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcf(float x) throw (); +# 6385 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double lgamma(double x) throw (); +# 6448 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcinv(double y); +# 6504 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcinvf(float y); +# 6562 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdfinv(double y); +# 6620 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdfinvf(float y); +# 6663 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdf(double y); +# 6706 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdff(float y); +# 6781 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcx(double x); +# 6856 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcxf(float x); +# 6990 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float lgammaf(float x) throw (); +# 7099 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tgamma(double x) throw (); +# 7208 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tgammaf(float x) throw (); +# 7221 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double copysign(double x, double y) throw (); +# 7234 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float copysignf(float x, float y) throw (); +# 7271 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nextafter(double x, double y) throw (); +# 7308 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nextafterf(float x, float y) throw (); +# 7324 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nan(const char *tagp) throw (); +# 7340 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nanf(const char *tagp) throw (); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinff(float) throw (); +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnanf(float) throw (); +# 7358 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finite(double) throw (); +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finitef(float) throw (); +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbit(double) throw (); +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnan(double) throw (); +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinf(double) throw (); + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitf(float) throw (); +# 7524 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fma(double x, double y, double z) throw (); +# 7682 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaf(float x, float y, float z) throw (); +# 7693 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitl(long double) throw (); + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finitel(long double) throw (); +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinfl(long double) throw (); +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnanl(long double) throw (); +# 7751 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acosf(float x) throw (); +# 7791 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinf(float x) throw (); +# 7831 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanf(float x) throw (); +# 7864 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atan2f(float y, float x) throw (); +# 7888 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cosf(float x) throw (); +# 7930 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinf(float x) throw (); +# 7972 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanf(float x) throw (); +# 7996 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float coshf(float x) throw (); +# 8037 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinhf(float x) throw (); +# 8067 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanhf(float x) throw (); +# 8118 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logf(float x) throw (); +# 8168 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expf(float x) throw (); +# 8219 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log10f(float x) throw (); +# 8274 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float modff(float x, float *iptr) throw (); +# 8582 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float powf(float x, float y) throw (); +# 8651 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sqrtf(float x) throw (); +# 8710 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ceilf(float x) throw (); +# 8782 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float floorf(float x) throw (); +# 8841 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmodf(float x, float y) throw (); +# 8856 "/usr/include/crt/math_functions.h" 3 4 +} + + +# 1 "/usr/include/c++/8/math.h" 1 3 4 +# 36 "/usr/include/c++/8/math.h" 3 4 +# 1 "/usr/include/c++/8/cmath" 1 3 4 +# 39 "/usr/include/c++/8/cmath" 3 4 + +# 40 "/usr/include/c++/8/cmath" 3 + + +# 1 "/usr/include/c++/8/bits/cpp_type_traits.h" 1 3 +# 35 "/usr/include/c++/8/bits/cpp_type_traits.h" 3 + +# 36 "/usr/include/c++/8/bits/cpp_type_traits.h" 3 +# 67 "/usr/include/c++/8/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; + }; + + + + 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; + }; +# 261 "/usr/include/c++/8/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; }; +# 278 "/usr/include/c++/8/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; + }; +# 408 "/usr/include/c++/8/bits/cpp_type_traits.h" 3 + 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++/8/cmath" 2 3 +# 1 "/usr/include/c++/8/ext/type_traits.h" 1 3 +# 32 "/usr/include/c++/8/ext/type_traits.h" 3 + +# 33 "/usr/include/c++/8/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::__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++/8/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 +# 138 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h" 1 3 4 +# 139 "/usr/include/math.h" 2 3 4 +# 149 "/usr/include/math.h" 3 4 +typedef float float_t; +typedef double double_t; +# 190 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/fp-logb.h" 1 3 4 +# 191 "/usr/include/math.h" 2 3 4 +# 233 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/fp-fast.h" 1 3 4 +# 234 "/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, + }; +# 289 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4 +# 21 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassify (double __value) throw () + __attribute__ ((__const__)); + + +extern int __signbit (double __value) throw () + __attribute__ ((__const__)); + + + +extern int __isinf (double __value) throw () __attribute__ ((__const__)); + + +extern int __finite (double __value) throw () __attribute__ ((__const__)); + + +extern int __isnan (double __value) throw () __attribute__ ((__const__)); + + +extern int __iseqsig (double __x, double __y) throw (); + + +extern int __issignaling (double __value) throw () + __attribute__ ((__const__)); +# 290 "/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) throw (); extern double __acos (double __x) throw (); + +extern double asin (double __x) throw (); extern double __asin (double __x) throw (); + +extern double atan (double __x) throw (); extern double __atan (double __x) throw (); + +extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw (); + + + extern double cos (double __x) throw (); extern double __cos (double __x) throw (); + + extern double sin (double __x) throw (); extern double __sin (double __x) throw (); + +extern double tan (double __x) throw (); extern double __tan (double __x) throw (); + + + + +extern double cosh (double __x) throw (); extern double __cosh (double __x) throw (); + +extern double sinh (double __x) throw (); extern double __sinh (double __x) throw (); + +extern double tanh (double __x) throw (); extern double __tanh (double __x) throw (); + + + + extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw () + ; + + + + +extern double acosh (double __x) throw (); extern double __acosh (double __x) throw (); + +extern double asinh (double __x) throw (); extern double __asinh (double __x) throw (); + +extern double atanh (double __x) throw (); extern double __atanh (double __x) throw (); + + + + + + extern double exp (double __x) throw (); extern double __exp (double __x) throw (); + + +extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw (); + + +extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw (); + + + extern double log (double __x) throw (); extern double __log (double __x) throw (); + + +extern double log10 (double __x) throw (); extern double __log10 (double __x) throw (); + + +extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw () __attribute__ ((__nonnull__ (2))); + + + +extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw (); + + + + +extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw (); + + +extern double log1p (double __x) throw (); extern double __log1p (double __x) throw (); + + +extern double logb (double __x) throw (); extern double __logb (double __x) throw (); + + + + +extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw (); + + +extern double log2 (double __x) throw (); extern double __log2 (double __x) throw (); + + + + + + + extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw (); + + +extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw (); + + + +extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw (); + + + + +extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw (); + + + + + + +extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__)); + + +extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__)); + + +extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__)); + + +extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw (); +# 182 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int finite (double __value) throw () __attribute__ ((__const__)); + + +extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw (); + + + +extern double significand (double __x) throw (); extern double __significand (double __x) throw (); + + + + + + +extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__)); + + + + +extern double nan (const char *__tagb) throw (); extern double __nan (const char *__tagb) throw (); +# 217 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern double j0 (double) throw (); extern double __j0 (double) throw (); +extern double j1 (double) throw (); extern double __j1 (double) throw (); +extern double jn (int, double) throw (); extern double __jn (int, double) throw (); +extern double y0 (double) throw (); extern double __y0 (double) throw (); +extern double y1 (double) throw (); extern double __y1 (double) throw (); +extern double yn (int, double) throw (); extern double __yn (int, double) throw (); + + + + + +extern double erf (double) throw (); extern double __erf (double) throw (); +extern double erfc (double) throw (); extern double __erfc (double) throw (); +extern double lgamma (double) throw (); extern double __lgamma (double) throw (); + + + + +extern double tgamma (double) throw (); extern double __tgamma (double) throw (); + + + + + +extern double gamma (double) throw (); extern double __gamma (double) throw (); + + + + + + + +extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw (); + + + + + + +extern double rint (double __x) throw (); extern double __rint (double __x) throw (); + + +extern double nextafter (double __x, double __y) throw (); extern double __nextafter (double __x, double __y) throw (); + +extern double nexttoward (double __x, long double __y) throw (); extern double __nexttoward (double __x, long double __y) throw (); + + + + +extern double nextdown (double __x) throw (); extern double __nextdown (double __x) throw (); + +extern double nextup (double __x) throw (); extern double __nextup (double __x) throw (); + + + +extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw (); + + + +extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw (); + + + +extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw (); + + + + +extern long int llogb (double __x) throw (); extern long int __llogb (double __x) throw (); + + + + +extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw (); + + + +extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw (); + + + +extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__)); + + + +extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__)); + + + + +extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw (); + + + + + + +extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw (); +__extension__ +extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw (); + + + +extern long int lround (double __x) throw (); extern long int __lround (double __x) throw (); +__extension__ +extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw (); + + + +extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw (); + + +extern double fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__)); + + +extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__)); + + +extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw (); + + + + +extern double roundeven (double __x) throw () __attribute__ ((__const__)); extern double __roundeven (double __x) throw () __attribute__ ((__const__)); + + + +extern __intmax_t fromfp (double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) throw () + ; + + + +extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) throw () + ; + + + + +extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) throw () + ; + + + + +extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) throw () + ; + + +extern double fmaxmag (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmaxmag (double __x, double __y) throw () __attribute__ ((__const__)); + + +extern double fminmag (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fminmag (double __x, double __y) throw () __attribute__ ((__const__)); + + +extern int canonicalize (double *__cx, const double *__x) throw (); + + + + +extern int totalorder (const double *__x, const double *__y) throw () + + __attribute__ ((__pure__)); + + +extern int totalordermag (const double *__x, const double *__y) throw () + + __attribute__ ((__pure__)); + + +extern double getpayload (const double *__x) throw (); extern double __getpayload (const double *__x) throw (); + + +extern int setpayload (double *__x, double __payload) throw (); + + +extern int setpayloadsig (double *__x, double __payload) throw (); + + + + + + + +extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw (); +# 291 "/usr/include/math.h" 2 3 4 +# 306 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4 +# 21 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyf (float __value) throw () + __attribute__ ((__const__)); + + +extern int __signbitf (float __value) throw () + __attribute__ ((__const__)); + + + +extern int __isinff (float __value) throw () __attribute__ ((__const__)); + + +extern int __finitef (float __value) throw () __attribute__ ((__const__)); + + +extern int __isnanf (float __value) throw () __attribute__ ((__const__)); + + +extern int __iseqsigf (float __x, float __y) throw (); + + +extern int __issignalingf (float __value) throw () + __attribute__ ((__const__)); +# 307 "/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) throw (); extern float __acosf (float __x) throw (); + +extern float asinf (float __x) throw (); extern float __asinf (float __x) throw (); + +extern float atanf (float __x) throw (); extern float __atanf (float __x) throw (); + +extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw (); + + + extern float cosf (float __x) throw (); extern float __cosf (float __x) throw (); + + extern float sinf (float __x) throw (); extern float __sinf (float __x) throw (); + +extern float tanf (float __x) throw (); extern float __tanf (float __x) throw (); + + + + +extern float coshf (float __x) throw (); extern float __coshf (float __x) throw (); + +extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw (); + +extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw (); + + + + extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw () + ; + + + + +extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw (); + +extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw (); + +extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw (); + + + + + + extern float expf (float __x) throw (); extern float __expf (float __x) throw (); + + +extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw (); + + +extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw (); + + + extern float logf (float __x) throw (); extern float __logf (float __x) throw (); + + +extern float log10f (float __x) throw (); extern float __log10f (float __x) throw (); + + +extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw () __attribute__ ((__nonnull__ (2))); + + + +extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw (); + + + + +extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw (); + + +extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw (); + + +extern float logbf (float __x) throw (); extern float __logbf (float __x) throw (); + + + + +extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw (); + + +extern float log2f (float __x) throw (); extern float __log2f (float __x) throw (); + + + + + + + extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw (); + + +extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw (); + + + +extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw (); + + + + +extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw (); + + + + + + +extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__)); + + +extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__)); + + +extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__)); + + +extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw (); +# 177 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isinff (float __value) throw () __attribute__ ((__const__)); + + + + +extern int finitef (float __value) throw () __attribute__ ((__const__)); + + +extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw (); + + + +extern float significandf (float __x) throw (); extern float __significandf (float __x) throw (); + + + + + + +extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__)); + + + + +extern float nanf (const char *__tagb) throw (); extern float __nanf (const char *__tagb) throw (); +# 211 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isnanf (float __value) throw () __attribute__ ((__const__)); + + + + + +extern float j0f (float) throw (); extern float __j0f (float) throw (); +extern float j1f (float) throw (); extern float __j1f (float) throw (); +extern float jnf (int, float) throw (); extern float __jnf (int, float) throw (); +extern float y0f (float) throw (); extern float __y0f (float) throw (); +extern float y1f (float) throw (); extern float __y1f (float) throw (); +extern float ynf (int, float) throw (); extern float __ynf (int, float) throw (); + + + + + +extern float erff (float) throw (); extern float __erff (float) throw (); +extern float erfcf (float) throw (); extern float __erfcf (float) throw (); +extern float lgammaf (float) throw (); extern float __lgammaf (float) throw (); + + + + +extern float tgammaf (float) throw (); extern float __tgammaf (float) throw (); + + + + + +extern float gammaf (float) throw (); extern float __gammaf (float) throw (); + + + + + + + +extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw (); + + + + + + +extern float rintf (float __x) throw (); extern float __rintf (float __x) throw (); + + +extern float nextafterf (float __x, float __y) throw (); extern float __nextafterf (float __x, float __y) throw (); + +extern float nexttowardf (float __x, long double __y) throw (); extern float __nexttowardf (float __x, long double __y) throw (); + + + + +extern float nextdownf (float __x) throw (); extern float __nextdownf (float __x) throw (); + +extern float nextupf (float __x) throw (); extern float __nextupf (float __x) throw (); + + + +extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw (); + + + +extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw (); + + + +extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw (); + + + + +extern long int llogbf (float __x) throw (); extern long int __llogbf (float __x) throw (); + + + + +extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw (); + + + +extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw (); + + + +extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__)); + + + +extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__)); + + + + +extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw (); + + + + + + +extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw (); +__extension__ +extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw (); + + + +extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw (); +__extension__ +extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw (); + + + +extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw (); + + +extern float fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); + + +extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__)); + + +extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw (); + + + + +extern float roundevenf (float __x) throw () __attribute__ ((__const__)); extern float __roundevenf (float __x) throw () __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) throw () + ; + + + +extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) throw () + ; + + + + +extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) throw () + ; + + + + +extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) throw () + ; + + +extern float fmaxmagf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxmagf (float __x, float __y) throw () __attribute__ ((__const__)); + + +extern float fminmagf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminmagf (float __x, float __y) throw () __attribute__ ((__const__)); + + +extern int canonicalizef (float *__cx, const float *__x) throw (); + + + + +extern int totalorderf (const float *__x, const float *__y) throw () + + __attribute__ ((__pure__)); + + +extern int totalordermagf (const float *__x, const float *__y) throw () + + __attribute__ ((__pure__)); + + +extern float getpayloadf (const float *__x) throw (); extern float __getpayloadf (const float *__x) throw (); + + +extern int setpayloadf (float *__x, float __payload) throw (); + + +extern int setpayloadsigf (float *__x, float __payload) throw (); + + + + + + + +extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw (); +# 308 "/usr/include/math.h" 2 3 4 +# 349 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4 +# 21 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyl (long double __value) throw () + __attribute__ ((__const__)); + + +extern int __signbitl (long double __value) throw () + __attribute__ ((__const__)); + + + +extern int __isinfl (long double __value) throw () __attribute__ ((__const__)); + + +extern int __finitel (long double __value) throw () __attribute__ ((__const__)); + + +extern int __isnanl (long double __value) throw () __attribute__ ((__const__)); + + +extern int __iseqsigl (long double __x, long double __y) throw (); + + +extern int __issignalingl (long double __value) throw () + __attribute__ ((__const__)); +# 350 "/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) throw (); extern long double __acosl (long double __x) throw (); + +extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw (); + +extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw (); + +extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw (); + + + extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw (); + + extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw (); + +extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw (); + + + + +extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw (); + +extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw (); + +extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw (); + + + + extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw () + ; + + + + +extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw (); + +extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw (); + +extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw (); + + + + + + extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw (); + + +extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw (); + + +extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw (); + + + extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw (); + + +extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw (); + + +extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw () __attribute__ ((__nonnull__ (2))); + + + +extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw (); + + + + +extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw (); + + +extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw (); + + +extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw (); + + + + +extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw (); + + +extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw (); + + + + + + + extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw (); + + +extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw (); + + + +extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw (); + + + + +extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw (); + + + + + + +extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__)); + + +extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__)); + + +extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__)); + + +extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw (); +# 177 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isinfl (long double __value) throw () __attribute__ ((__const__)); + + + + +extern int finitel (long double __value) throw () __attribute__ ((__const__)); + + +extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw (); + + + +extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw (); + + + + + + +extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); + + + + +extern long double nanl (const char *__tagb) throw (); extern long double __nanl (const char *__tagb) throw (); +# 211 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isnanl (long double __value) throw () __attribute__ ((__const__)); + + + + + +extern long double j0l (long double) throw (); extern long double __j0l (long double) throw (); +extern long double j1l (long double) throw (); extern long double __j1l (long double) throw (); +extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw (); +extern long double y0l (long double) throw (); extern long double __y0l (long double) throw (); +extern long double y1l (long double) throw (); extern long double __y1l (long double) throw (); +extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw (); + + + + + +extern long double erfl (long double) throw (); extern long double __erfl (long double) throw (); +extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw (); +extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw (); + + + + +extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw (); + + + + + +extern long double gammal (long double) throw (); extern long double __gammal (long double) throw (); + + + + + + + +extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw (); + + + + + + +extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw (); + + +extern long double nextafterl (long double __x, long double __y) throw (); extern long double __nextafterl (long double __x, long double __y) throw (); + +extern long double nexttowardl (long double __x, long double __y) throw (); extern long double __nexttowardl (long double __x, long double __y) throw (); + + + + +extern long double nextdownl (long double __x) throw (); extern long double __nextdownl (long double __x) throw (); + +extern long double nextupl (long double __x) throw (); extern long double __nextupl (long double __x) throw (); + + + +extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw (); + + + +extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw (); + + + +extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw (); + + + + +extern long int llogbl (long double __x) throw (); extern long int __llogbl (long double __x) throw (); + + + + +extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw (); + + + +extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw (); + + + +extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__)); + + + +extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__)); + + + + +extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw (); + + + + + + +extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw (); +__extension__ +extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw (); + + + +extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw (); +__extension__ +extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw (); + + + +extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw (); + + +extern long double fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); + + +extern long double fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); + + +extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw (); + + + + +extern long double roundevenl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundevenl (long double __x) throw () __attribute__ ((__const__)); + + + +extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) throw () + ; + + + +extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) throw () + ; + + + + +extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) throw () + ; + + + + +extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) throw () + ; + + +extern long double fmaxmagl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxmagl (long double __x, long double __y) throw () __attribute__ ((__const__)); + + +extern long double fminmagl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminmagl (long double __x, long double __y) throw () __attribute__ ((__const__)); + + +extern int canonicalizel (long double *__cx, const long double *__x) throw (); + + + + +extern int totalorderl (const long double *__x, const long double *__y) throw () + + __attribute__ ((__pure__)); + + +extern int totalordermagl (const long double *__x, const long double *__y) throw () + + __attribute__ ((__pure__)); + + +extern long double getpayloadl (const long double *__x) throw (); extern long double __getpayloadl (const long double *__x) throw (); + + +extern int setpayloadl (long double *__x, long double __payload) throw (); + + +extern int setpayloadsigl (long double *__x, long double __payload) throw (); + + + + + + + +extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw (); +# 351 "/usr/include/math.h" 2 3 4 +# 389 "/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) throw (); extern _Float32 __acosf32 (_Float32 __x) throw (); + +extern _Float32 asinf32 (_Float32 __x) throw (); extern _Float32 __asinf32 (_Float32 __x) throw (); + +extern _Float32 atanf32 (_Float32 __x) throw (); extern _Float32 __atanf32 (_Float32 __x) throw (); + +extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) throw (); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) throw (); + + + extern _Float32 cosf32 (_Float32 __x) throw (); extern _Float32 __cosf32 (_Float32 __x) throw (); + + extern _Float32 sinf32 (_Float32 __x) throw (); extern _Float32 __sinf32 (_Float32 __x) throw (); + +extern _Float32 tanf32 (_Float32 __x) throw (); extern _Float32 __tanf32 (_Float32 __x) throw (); + + + + +extern _Float32 coshf32 (_Float32 __x) throw (); extern _Float32 __coshf32 (_Float32 __x) throw (); + +extern _Float32 sinhf32 (_Float32 __x) throw (); extern _Float32 __sinhf32 (_Float32 __x) throw (); + +extern _Float32 tanhf32 (_Float32 __x) throw (); extern _Float32 __tanhf32 (_Float32 __x) throw (); + + + + extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) throw (); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) throw () + ; + + + + +extern _Float32 acoshf32 (_Float32 __x) throw (); extern _Float32 __acoshf32 (_Float32 __x) throw (); + +extern _Float32 asinhf32 (_Float32 __x) throw (); extern _Float32 __asinhf32 (_Float32 __x) throw (); + +extern _Float32 atanhf32 (_Float32 __x) throw (); extern _Float32 __atanhf32 (_Float32 __x) throw (); + + + + + + extern _Float32 expf32 (_Float32 __x) throw (); extern _Float32 __expf32 (_Float32 __x) throw (); + + +extern _Float32 frexpf32 (_Float32 __x, int *__exponent) throw (); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) throw (); + + +extern _Float32 ldexpf32 (_Float32 __x, int __exponent) throw (); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) throw (); + + + extern _Float32 logf32 (_Float32 __x) throw (); extern _Float32 __logf32 (_Float32 __x) throw (); + + +extern _Float32 log10f32 (_Float32 __x) throw (); extern _Float32 __log10f32 (_Float32 __x) throw (); + + +extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) throw (); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) throw () __attribute__ ((__nonnull__ (2))); + + + +extern _Float32 exp10f32 (_Float32 __x) throw (); extern _Float32 __exp10f32 (_Float32 __x) throw (); + + + + +extern _Float32 expm1f32 (_Float32 __x) throw (); extern _Float32 __expm1f32 (_Float32 __x) throw (); + + +extern _Float32 log1pf32 (_Float32 __x) throw (); extern _Float32 __log1pf32 (_Float32 __x) throw (); + + +extern _Float32 logbf32 (_Float32 __x) throw (); extern _Float32 __logbf32 (_Float32 __x) throw (); + + + + +extern _Float32 exp2f32 (_Float32 __x) throw (); extern _Float32 __exp2f32 (_Float32 __x) throw (); + + +extern _Float32 log2f32 (_Float32 __x) throw (); extern _Float32 __log2f32 (_Float32 __x) throw (); + + + + + + + extern _Float32 powf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) throw (); + + +extern _Float32 sqrtf32 (_Float32 __x) throw (); extern _Float32 __sqrtf32 (_Float32 __x) throw (); + + + +extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) throw (); + + + + +extern _Float32 cbrtf32 (_Float32 __x) throw (); extern _Float32 __cbrtf32 (_Float32 __x) throw (); + + + + + + +extern _Float32 ceilf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __ceilf32 (_Float32 __x) throw () __attribute__ ((__const__)); + + +extern _Float32 fabsf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __fabsf32 (_Float32 __x) throw () __attribute__ ((__const__)); + + +extern _Float32 floorf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __floorf32 (_Float32 __x) throw () __attribute__ ((__const__)); + + +extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) throw (); +# 196 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __copysignf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); + + + + +extern _Float32 nanf32 (const char *__tagb) throw (); extern _Float32 __nanf32 (const char *__tagb) throw (); +# 217 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32 j0f32 (_Float32) throw (); extern _Float32 __j0f32 (_Float32) throw (); +extern _Float32 j1f32 (_Float32) throw (); extern _Float32 __j1f32 (_Float32) throw (); +extern _Float32 jnf32 (int, _Float32) throw (); extern _Float32 __jnf32 (int, _Float32) throw (); +extern _Float32 y0f32 (_Float32) throw (); extern _Float32 __y0f32 (_Float32) throw (); +extern _Float32 y1f32 (_Float32) throw (); extern _Float32 __y1f32 (_Float32) throw (); +extern _Float32 ynf32 (int, _Float32) throw (); extern _Float32 __ynf32 (int, _Float32) throw (); + + + + + +extern _Float32 erff32 (_Float32) throw (); extern _Float32 __erff32 (_Float32) throw (); +extern _Float32 erfcf32 (_Float32) throw (); extern _Float32 __erfcf32 (_Float32) throw (); +extern _Float32 lgammaf32 (_Float32) throw (); extern _Float32 __lgammaf32 (_Float32) throw (); + + + + +extern _Float32 tgammaf32 (_Float32) throw (); extern _Float32 __tgammaf32 (_Float32) throw (); +# 249 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32 lgammaf32_r (_Float32, int *__signgamp) throw (); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) throw (); + + + + + + +extern _Float32 rintf32 (_Float32 __x) throw (); extern _Float32 __rintf32 (_Float32 __x) throw (); + + +extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) throw (); + + + + + + +extern _Float32 nextdownf32 (_Float32 __x) throw (); extern _Float32 __nextdownf32 (_Float32 __x) throw (); + +extern _Float32 nextupf32 (_Float32 __x) throw (); extern _Float32 __nextupf32 (_Float32 __x) throw (); + + + +extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) throw (); + + + +extern _Float32 scalbnf32 (_Float32 __x, int __n) throw (); extern _Float32 __scalbnf32 (_Float32 __x, int __n) throw (); + + + +extern int ilogbf32 (_Float32 __x) throw (); extern int __ilogbf32 (_Float32 __x) throw (); + + + + +extern long int llogbf32 (_Float32 __x) throw (); extern long int __llogbf32 (_Float32 __x) throw (); + + + + +extern _Float32 scalblnf32 (_Float32 __x, long int __n) throw (); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) throw (); + + + +extern _Float32 nearbyintf32 (_Float32 __x) throw (); extern _Float32 __nearbyintf32 (_Float32 __x) throw (); + + + +extern _Float32 roundf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __roundf32 (_Float32 __x) throw () __attribute__ ((__const__)); + + + +extern _Float32 truncf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __truncf32 (_Float32 __x) throw () __attribute__ ((__const__)); + + + + +extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) throw (); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) throw (); + + + + + + +extern long int lrintf32 (_Float32 __x) throw (); extern long int __lrintf32 (_Float32 __x) throw (); +__extension__ +extern long long int llrintf32 (_Float32 __x) throw (); extern long long int __llrintf32 (_Float32 __x) throw (); + + + +extern long int lroundf32 (_Float32 __x) throw (); extern long int __lroundf32 (_Float32 __x) throw (); +__extension__ +extern long long int llroundf32 (_Float32 __x) throw (); extern long long int __llroundf32 (_Float32 __x) throw (); + + + +extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) throw (); + + +extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fmaxf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); + + +extern _Float32 fminf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fminf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); + + +extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) throw (); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) throw (); + + + + +extern _Float32 roundevenf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __roundevenf32 (_Float32 __x) throw () __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) throw () + ; + + + +extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) throw () + ; + + + + +extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw () + ; + + + + +extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw () + ; + + +extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fmaxmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); + + +extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fminmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); + + +extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) throw (); + + + + +extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) throw () + + __attribute__ ((__pure__)); + + +extern int totalordermagf32 (const _Float32 *__x, const _Float32 *__y) throw () + + __attribute__ ((__pure__)); + + +extern _Float32 getpayloadf32 (const _Float32 *__x) throw (); extern _Float32 __getpayloadf32 (const _Float32 *__x) throw (); + + +extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) throw (); + + +extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) throw (); +# 390 "/usr/include/math.h" 2 3 4 +# 406 "/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) throw (); extern _Float64 __acosf64 (_Float64 __x) throw (); + +extern _Float64 asinf64 (_Float64 __x) throw (); extern _Float64 __asinf64 (_Float64 __x) throw (); + +extern _Float64 atanf64 (_Float64 __x) throw (); extern _Float64 __atanf64 (_Float64 __x) throw (); + +extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) throw (); extern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) throw (); + + + extern _Float64 cosf64 (_Float64 __x) throw (); extern _Float64 __cosf64 (_Float64 __x) throw (); + + extern _Float64 sinf64 (_Float64 __x) throw (); extern _Float64 __sinf64 (_Float64 __x) throw (); + +extern _Float64 tanf64 (_Float64 __x) throw (); extern _Float64 __tanf64 (_Float64 __x) throw (); + + + + +extern _Float64 coshf64 (_Float64 __x) throw (); extern _Float64 __coshf64 (_Float64 __x) throw (); + +extern _Float64 sinhf64 (_Float64 __x) throw (); extern _Float64 __sinhf64 (_Float64 __x) throw (); + +extern _Float64 tanhf64 (_Float64 __x) throw (); extern _Float64 __tanhf64 (_Float64 __x) throw (); + + + + extern void sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) throw (); extern void __sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) throw () + ; + + + + +extern _Float64 acoshf64 (_Float64 __x) throw (); extern _Float64 __acoshf64 (_Float64 __x) throw (); + +extern _Float64 asinhf64 (_Float64 __x) throw (); extern _Float64 __asinhf64 (_Float64 __x) throw (); + +extern _Float64 atanhf64 (_Float64 __x) throw (); extern _Float64 __atanhf64 (_Float64 __x) throw (); + + + + + + extern _Float64 expf64 (_Float64 __x) throw (); extern _Float64 __expf64 (_Float64 __x) throw (); + + +extern _Float64 frexpf64 (_Float64 __x, int *__exponent) throw (); extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) throw (); + + +extern _Float64 ldexpf64 (_Float64 __x, int __exponent) throw (); extern _Float64 __ldexpf64 (_Float64 __x, int __exponent) throw (); + + + extern _Float64 logf64 (_Float64 __x) throw (); extern _Float64 __logf64 (_Float64 __x) throw (); + + +extern _Float64 log10f64 (_Float64 __x) throw (); extern _Float64 __log10f64 (_Float64 __x) throw (); + + +extern _Float64 modff64 (_Float64 __x, _Float64 *__iptr) throw (); extern _Float64 __modff64 (_Float64 __x, _Float64 *__iptr) throw () __attribute__ ((__nonnull__ (2))); + + + +extern _Float64 exp10f64 (_Float64 __x) throw (); extern _Float64 __exp10f64 (_Float64 __x) throw (); + + + + +extern _Float64 expm1f64 (_Float64 __x) throw (); extern _Float64 __expm1f64 (_Float64 __x) throw (); + + +extern _Float64 log1pf64 (_Float64 __x) throw (); extern _Float64 __log1pf64 (_Float64 __x) throw (); + + +extern _Float64 logbf64 (_Float64 __x) throw (); extern _Float64 __logbf64 (_Float64 __x) throw (); + + + + +extern _Float64 exp2f64 (_Float64 __x) throw (); extern _Float64 __exp2f64 (_Float64 __x) throw (); + + +extern _Float64 log2f64 (_Float64 __x) throw (); extern _Float64 __log2f64 (_Float64 __x) throw (); + + + + + + + extern _Float64 powf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __powf64 (_Float64 __x, _Float64 __y) throw (); + + +extern _Float64 sqrtf64 (_Float64 __x) throw (); extern _Float64 __sqrtf64 (_Float64 __x) throw (); + + + +extern _Float64 hypotf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __hypotf64 (_Float64 __x, _Float64 __y) throw (); + + + + +extern _Float64 cbrtf64 (_Float64 __x) throw (); extern _Float64 __cbrtf64 (_Float64 __x) throw (); + + + + + + +extern _Float64 ceilf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __ceilf64 (_Float64 __x) throw () __attribute__ ((__const__)); + + +extern _Float64 fabsf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __fabsf64 (_Float64 __x) throw () __attribute__ ((__const__)); + + +extern _Float64 floorf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __floorf64 (_Float64 __x) throw () __attribute__ ((__const__)); + + +extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __fmodf64 (_Float64 __x, _Float64 __y) throw (); +# 196 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __copysignf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); + + + + +extern _Float64 nanf64 (const char *__tagb) throw (); extern _Float64 __nanf64 (const char *__tagb) throw (); +# 217 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64 j0f64 (_Float64) throw (); extern _Float64 __j0f64 (_Float64) throw (); +extern _Float64 j1f64 (_Float64) throw (); extern _Float64 __j1f64 (_Float64) throw (); +extern _Float64 jnf64 (int, _Float64) throw (); extern _Float64 __jnf64 (int, _Float64) throw (); +extern _Float64 y0f64 (_Float64) throw (); extern _Float64 __y0f64 (_Float64) throw (); +extern _Float64 y1f64 (_Float64) throw (); extern _Float64 __y1f64 (_Float64) throw (); +extern _Float64 ynf64 (int, _Float64) throw (); extern _Float64 __ynf64 (int, _Float64) throw (); + + + + + +extern _Float64 erff64 (_Float64) throw (); extern _Float64 __erff64 (_Float64) throw (); +extern _Float64 erfcf64 (_Float64) throw (); extern _Float64 __erfcf64 (_Float64) throw (); +extern _Float64 lgammaf64 (_Float64) throw (); extern _Float64 __lgammaf64 (_Float64) throw (); + + + + +extern _Float64 tgammaf64 (_Float64) throw (); extern _Float64 __tgammaf64 (_Float64) throw (); +# 249 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64 lgammaf64_r (_Float64, int *__signgamp) throw (); extern _Float64 __lgammaf64_r (_Float64, int *__signgamp) throw (); + + + + + + +extern _Float64 rintf64 (_Float64 __x) throw (); extern _Float64 __rintf64 (_Float64 __x) throw (); + + +extern _Float64 nextafterf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __nextafterf64 (_Float64 __x, _Float64 __y) throw (); + + + + + + +extern _Float64 nextdownf64 (_Float64 __x) throw (); extern _Float64 __nextdownf64 (_Float64 __x) throw (); + +extern _Float64 nextupf64 (_Float64 __x) throw (); extern _Float64 __nextupf64 (_Float64 __x) throw (); + + + +extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) throw (); + + + +extern _Float64 scalbnf64 (_Float64 __x, int __n) throw (); extern _Float64 __scalbnf64 (_Float64 __x, int __n) throw (); + + + +extern int ilogbf64 (_Float64 __x) throw (); extern int __ilogbf64 (_Float64 __x) throw (); + + + + +extern long int llogbf64 (_Float64 __x) throw (); extern long int __llogbf64 (_Float64 __x) throw (); + + + + +extern _Float64 scalblnf64 (_Float64 __x, long int __n) throw (); extern _Float64 __scalblnf64 (_Float64 __x, long int __n) throw (); + + + +extern _Float64 nearbyintf64 (_Float64 __x) throw (); extern _Float64 __nearbyintf64 (_Float64 __x) throw (); + + + +extern _Float64 roundf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __roundf64 (_Float64 __x) throw () __attribute__ ((__const__)); + + + +extern _Float64 truncf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __truncf64 (_Float64 __x) throw () __attribute__ ((__const__)); + + + + +extern _Float64 remquof64 (_Float64 __x, _Float64 __y, int *__quo) throw (); extern _Float64 __remquof64 (_Float64 __x, _Float64 __y, int *__quo) throw (); + + + + + + +extern long int lrintf64 (_Float64 __x) throw (); extern long int __lrintf64 (_Float64 __x) throw (); +__extension__ +extern long long int llrintf64 (_Float64 __x) throw (); extern long long int __llrintf64 (_Float64 __x) throw (); + + + +extern long int lroundf64 (_Float64 __x) throw (); extern long int __lroundf64 (_Float64 __x) throw (); +__extension__ +extern long long int llroundf64 (_Float64 __x) throw (); extern long long int __llroundf64 (_Float64 __x) throw (); + + + +extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __fdimf64 (_Float64 __x, _Float64 __y) throw (); + + +extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fmaxf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); + + +extern _Float64 fminf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fminf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); + + +extern _Float64 fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) throw (); extern _Float64 __fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) throw (); + + + + +extern _Float64 roundevenf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __roundevenf64 (_Float64 __x) throw () __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf64 (_Float64 __x, int __round, unsigned int __width) throw () + ; + + + +extern __uintmax_t ufromfpf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf64 (_Float64 __x, int __round, unsigned int __width) throw () + ; + + + + +extern __intmax_t fromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw () + ; + + + + +extern __uintmax_t ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw () + ; + + +extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fmaxmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); + + +extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fminmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); + + +extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) throw (); + + + + +extern int totalorderf64 (const _Float64 *__x, const _Float64 *__y) throw () + + __attribute__ ((__pure__)); + + +extern int totalordermagf64 (const _Float64 *__x, const _Float64 *__y) throw () + + __attribute__ ((__pure__)); + + +extern _Float64 getpayloadf64 (const _Float64 *__x) throw (); extern _Float64 __getpayloadf64 (const _Float64 *__x) throw (); + + +extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) throw (); + + +extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) throw (); +# 407 "/usr/include/math.h" 2 3 4 +# 440 "/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) throw (); extern _Float32x __acosf32x (_Float32x __x) throw (); + +extern _Float32x asinf32x (_Float32x __x) throw (); extern _Float32x __asinf32x (_Float32x __x) throw (); + +extern _Float32x atanf32x (_Float32x __x) throw (); extern _Float32x __atanf32x (_Float32x __x) throw (); + +extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) throw (); extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) throw (); + + + extern _Float32x cosf32x (_Float32x __x) throw (); extern _Float32x __cosf32x (_Float32x __x) throw (); + + extern _Float32x sinf32x (_Float32x __x) throw (); extern _Float32x __sinf32x (_Float32x __x) throw (); + +extern _Float32x tanf32x (_Float32x __x) throw (); extern _Float32x __tanf32x (_Float32x __x) throw (); + + + + +extern _Float32x coshf32x (_Float32x __x) throw (); extern _Float32x __coshf32x (_Float32x __x) throw (); + +extern _Float32x sinhf32x (_Float32x __x) throw (); extern _Float32x __sinhf32x (_Float32x __x) throw (); + +extern _Float32x tanhf32x (_Float32x __x) throw (); extern _Float32x __tanhf32x (_Float32x __x) throw (); + + + + extern void sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) throw (); extern void __sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) throw () + ; + + + + +extern _Float32x acoshf32x (_Float32x __x) throw (); extern _Float32x __acoshf32x (_Float32x __x) throw (); + +extern _Float32x asinhf32x (_Float32x __x) throw (); extern _Float32x __asinhf32x (_Float32x __x) throw (); + +extern _Float32x atanhf32x (_Float32x __x) throw (); extern _Float32x __atanhf32x (_Float32x __x) throw (); + + + + + + extern _Float32x expf32x (_Float32x __x) throw (); extern _Float32x __expf32x (_Float32x __x) throw (); + + +extern _Float32x frexpf32x (_Float32x __x, int *__exponent) throw (); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) throw (); + + +extern _Float32x ldexpf32x (_Float32x __x, int __exponent) throw (); extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) throw (); + + + extern _Float32x logf32x (_Float32x __x) throw (); extern _Float32x __logf32x (_Float32x __x) throw (); + + +extern _Float32x log10f32x (_Float32x __x) throw (); extern _Float32x __log10f32x (_Float32x __x) throw (); + + +extern _Float32x modff32x (_Float32x __x, _Float32x *__iptr) throw (); extern _Float32x __modff32x (_Float32x __x, _Float32x *__iptr) throw () __attribute__ ((__nonnull__ (2))); + + + +extern _Float32x exp10f32x (_Float32x __x) throw (); extern _Float32x __exp10f32x (_Float32x __x) throw (); + + + + +extern _Float32x expm1f32x (_Float32x __x) throw (); extern _Float32x __expm1f32x (_Float32x __x) throw (); + + +extern _Float32x log1pf32x (_Float32x __x) throw (); extern _Float32x __log1pf32x (_Float32x __x) throw (); + + +extern _Float32x logbf32x (_Float32x __x) throw (); extern _Float32x __logbf32x (_Float32x __x) throw (); + + + + +extern _Float32x exp2f32x (_Float32x __x) throw (); extern _Float32x __exp2f32x (_Float32x __x) throw (); + + +extern _Float32x log2f32x (_Float32x __x) throw (); extern _Float32x __log2f32x (_Float32x __x) throw (); + + + + + + + extern _Float32x powf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __powf32x (_Float32x __x, _Float32x __y) throw (); + + +extern _Float32x sqrtf32x (_Float32x __x) throw (); extern _Float32x __sqrtf32x (_Float32x __x) throw (); + + + +extern _Float32x hypotf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __hypotf32x (_Float32x __x, _Float32x __y) throw (); + + + + +extern _Float32x cbrtf32x (_Float32x __x) throw (); extern _Float32x __cbrtf32x (_Float32x __x) throw (); + + + + + + +extern _Float32x ceilf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __ceilf32x (_Float32x __x) throw () __attribute__ ((__const__)); + + +extern _Float32x fabsf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __fabsf32x (_Float32x __x) throw () __attribute__ ((__const__)); + + +extern _Float32x floorf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __floorf32x (_Float32x __x) throw () __attribute__ ((__const__)); + + +extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) throw (); +# 196 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __copysignf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); + + + + +extern _Float32x nanf32x (const char *__tagb) throw (); extern _Float32x __nanf32x (const char *__tagb) throw (); +# 217 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32x j0f32x (_Float32x) throw (); extern _Float32x __j0f32x (_Float32x) throw (); +extern _Float32x j1f32x (_Float32x) throw (); extern _Float32x __j1f32x (_Float32x) throw (); +extern _Float32x jnf32x (int, _Float32x) throw (); extern _Float32x __jnf32x (int, _Float32x) throw (); +extern _Float32x y0f32x (_Float32x) throw (); extern _Float32x __y0f32x (_Float32x) throw (); +extern _Float32x y1f32x (_Float32x) throw (); extern _Float32x __y1f32x (_Float32x) throw (); +extern _Float32x ynf32x (int, _Float32x) throw (); extern _Float32x __ynf32x (int, _Float32x) throw (); + + + + + +extern _Float32x erff32x (_Float32x) throw (); extern _Float32x __erff32x (_Float32x) throw (); +extern _Float32x erfcf32x (_Float32x) throw (); extern _Float32x __erfcf32x (_Float32x) throw (); +extern _Float32x lgammaf32x (_Float32x) throw (); extern _Float32x __lgammaf32x (_Float32x) throw (); + + + + +extern _Float32x tgammaf32x (_Float32x) throw (); extern _Float32x __tgammaf32x (_Float32x) throw (); +# 249 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32x lgammaf32x_r (_Float32x, int *__signgamp) throw (); extern _Float32x __lgammaf32x_r (_Float32x, int *__signgamp) throw (); + + + + + + +extern _Float32x rintf32x (_Float32x __x) throw (); extern _Float32x __rintf32x (_Float32x __x) throw (); + + +extern _Float32x nextafterf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __nextafterf32x (_Float32x __x, _Float32x __y) throw (); + + + + + + +extern _Float32x nextdownf32x (_Float32x __x) throw (); extern _Float32x __nextdownf32x (_Float32x __x) throw (); + +extern _Float32x nextupf32x (_Float32x __x) throw (); extern _Float32x __nextupf32x (_Float32x __x) throw (); + + + +extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) throw (); + + + +extern _Float32x scalbnf32x (_Float32x __x, int __n) throw (); extern _Float32x __scalbnf32x (_Float32x __x, int __n) throw (); + + + +extern int ilogbf32x (_Float32x __x) throw (); extern int __ilogbf32x (_Float32x __x) throw (); + + + + +extern long int llogbf32x (_Float32x __x) throw (); extern long int __llogbf32x (_Float32x __x) throw (); + + + + +extern _Float32x scalblnf32x (_Float32x __x, long int __n) throw (); extern _Float32x __scalblnf32x (_Float32x __x, long int __n) throw (); + + + +extern _Float32x nearbyintf32x (_Float32x __x) throw (); extern _Float32x __nearbyintf32x (_Float32x __x) throw (); + + + +extern _Float32x roundf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __roundf32x (_Float32x __x) throw () __attribute__ ((__const__)); + + + +extern _Float32x truncf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __truncf32x (_Float32x __x) throw () __attribute__ ((__const__)); + + + + +extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) throw (); extern _Float32x __remquof32x (_Float32x __x, _Float32x __y, int *__quo) throw (); + + + + + + +extern long int lrintf32x (_Float32x __x) throw (); extern long int __lrintf32x (_Float32x __x) throw (); +__extension__ +extern long long int llrintf32x (_Float32x __x) throw (); extern long long int __llrintf32x (_Float32x __x) throw (); + + + +extern long int lroundf32x (_Float32x __x) throw (); extern long int __lroundf32x (_Float32x __x) throw (); +__extension__ +extern long long int llroundf32x (_Float32x __x) throw (); extern long long int __llroundf32x (_Float32x __x) throw (); + + + +extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) throw (); + + +extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fmaxf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); + + +extern _Float32x fminf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fminf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); + + +extern _Float32x fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) throw (); extern _Float32x __fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) throw (); + + + + +extern _Float32x roundevenf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __roundevenf32x (_Float32x __x) throw () __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf32x (_Float32x __x, int __round, unsigned int __width) throw () + ; + + + +extern __uintmax_t ufromfpf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf32x (_Float32x __x, int __round, unsigned int __width) throw () + ; + + + + +extern __intmax_t fromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw () + ; + + + + +extern __uintmax_t ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw () + ; + + +extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fmaxmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); + + +extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fminmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); + + +extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) throw (); + + + + +extern int totalorderf32x (const _Float32x *__x, const _Float32x *__y) throw () + + __attribute__ ((__pure__)); + + +extern int totalordermagf32x (const _Float32x *__x, const _Float32x *__y) throw () + + __attribute__ ((__pure__)); + + +extern _Float32x getpayloadf32x (const _Float32x *__x) throw (); extern _Float32x __getpayloadf32x (const _Float32x *__x) throw (); + + +extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) throw (); + + +extern int setpayloadsigf32x (_Float32x *__x, _Float32x __payload) throw (); +# 441 "/usr/include/math.h" 2 3 4 +# 457 "/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) throw (); extern _Float64x __acosf64x (_Float64x __x) throw (); + +extern _Float64x asinf64x (_Float64x __x) throw (); extern _Float64x __asinf64x (_Float64x __x) throw (); + +extern _Float64x atanf64x (_Float64x __x) throw (); extern _Float64x __atanf64x (_Float64x __x) throw (); + +extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) throw (); extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) throw (); + + + extern _Float64x cosf64x (_Float64x __x) throw (); extern _Float64x __cosf64x (_Float64x __x) throw (); + + extern _Float64x sinf64x (_Float64x __x) throw (); extern _Float64x __sinf64x (_Float64x __x) throw (); + +extern _Float64x tanf64x (_Float64x __x) throw (); extern _Float64x __tanf64x (_Float64x __x) throw (); + + + + +extern _Float64x coshf64x (_Float64x __x) throw (); extern _Float64x __coshf64x (_Float64x __x) throw (); + +extern _Float64x sinhf64x (_Float64x __x) throw (); extern _Float64x __sinhf64x (_Float64x __x) throw (); + +extern _Float64x tanhf64x (_Float64x __x) throw (); extern _Float64x __tanhf64x (_Float64x __x) throw (); + + + + extern void sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) throw (); extern void __sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) throw () + ; + + + + +extern _Float64x acoshf64x (_Float64x __x) throw (); extern _Float64x __acoshf64x (_Float64x __x) throw (); + +extern _Float64x asinhf64x (_Float64x __x) throw (); extern _Float64x __asinhf64x (_Float64x __x) throw (); + +extern _Float64x atanhf64x (_Float64x __x) throw (); extern _Float64x __atanhf64x (_Float64x __x) throw (); + + + + + + extern _Float64x expf64x (_Float64x __x) throw (); extern _Float64x __expf64x (_Float64x __x) throw (); + + +extern _Float64x frexpf64x (_Float64x __x, int *__exponent) throw (); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) throw (); + + +extern _Float64x ldexpf64x (_Float64x __x, int __exponent) throw (); extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) throw (); + + + extern _Float64x logf64x (_Float64x __x) throw (); extern _Float64x __logf64x (_Float64x __x) throw (); + + +extern _Float64x log10f64x (_Float64x __x) throw (); extern _Float64x __log10f64x (_Float64x __x) throw (); + + +extern _Float64x modff64x (_Float64x __x, _Float64x *__iptr) throw (); extern _Float64x __modff64x (_Float64x __x, _Float64x *__iptr) throw () __attribute__ ((__nonnull__ (2))); + + + +extern _Float64x exp10f64x (_Float64x __x) throw (); extern _Float64x __exp10f64x (_Float64x __x) throw (); + + + + +extern _Float64x expm1f64x (_Float64x __x) throw (); extern _Float64x __expm1f64x (_Float64x __x) throw (); + + +extern _Float64x log1pf64x (_Float64x __x) throw (); extern _Float64x __log1pf64x (_Float64x __x) throw (); + + +extern _Float64x logbf64x (_Float64x __x) throw (); extern _Float64x __logbf64x (_Float64x __x) throw (); + + + + +extern _Float64x exp2f64x (_Float64x __x) throw (); extern _Float64x __exp2f64x (_Float64x __x) throw (); + + +extern _Float64x log2f64x (_Float64x __x) throw (); extern _Float64x __log2f64x (_Float64x __x) throw (); + + + + + + + extern _Float64x powf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __powf64x (_Float64x __x, _Float64x __y) throw (); + + +extern _Float64x sqrtf64x (_Float64x __x) throw (); extern _Float64x __sqrtf64x (_Float64x __x) throw (); + + + +extern _Float64x hypotf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __hypotf64x (_Float64x __x, _Float64x __y) throw (); + + + + +extern _Float64x cbrtf64x (_Float64x __x) throw (); extern _Float64x __cbrtf64x (_Float64x __x) throw (); + + + + + + +extern _Float64x ceilf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __ceilf64x (_Float64x __x) throw () __attribute__ ((__const__)); + + +extern _Float64x fabsf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __fabsf64x (_Float64x __x) throw () __attribute__ ((__const__)); + + +extern _Float64x floorf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __floorf64x (_Float64x __x) throw () __attribute__ ((__const__)); + + +extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) throw (); +# 196 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __copysignf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); + + + + +extern _Float64x nanf64x (const char *__tagb) throw (); extern _Float64x __nanf64x (const char *__tagb) throw (); +# 217 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64x j0f64x (_Float64x) throw (); extern _Float64x __j0f64x (_Float64x) throw (); +extern _Float64x j1f64x (_Float64x) throw (); extern _Float64x __j1f64x (_Float64x) throw (); +extern _Float64x jnf64x (int, _Float64x) throw (); extern _Float64x __jnf64x (int, _Float64x) throw (); +extern _Float64x y0f64x (_Float64x) throw (); extern _Float64x __y0f64x (_Float64x) throw (); +extern _Float64x y1f64x (_Float64x) throw (); extern _Float64x __y1f64x (_Float64x) throw (); +extern _Float64x ynf64x (int, _Float64x) throw (); extern _Float64x __ynf64x (int, _Float64x) throw (); + + + + + +extern _Float64x erff64x (_Float64x) throw (); extern _Float64x __erff64x (_Float64x) throw (); +extern _Float64x erfcf64x (_Float64x) throw (); extern _Float64x __erfcf64x (_Float64x) throw (); +extern _Float64x lgammaf64x (_Float64x) throw (); extern _Float64x __lgammaf64x (_Float64x) throw (); + + + + +extern _Float64x tgammaf64x (_Float64x) throw (); extern _Float64x __tgammaf64x (_Float64x) throw (); +# 249 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64x lgammaf64x_r (_Float64x, int *__signgamp) throw (); extern _Float64x __lgammaf64x_r (_Float64x, int *__signgamp) throw (); + + + + + + +extern _Float64x rintf64x (_Float64x __x) throw (); extern _Float64x __rintf64x (_Float64x __x) throw (); + + +extern _Float64x nextafterf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __nextafterf64x (_Float64x __x, _Float64x __y) throw (); + + + + + + +extern _Float64x nextdownf64x (_Float64x __x) throw (); extern _Float64x __nextdownf64x (_Float64x __x) throw (); + +extern _Float64x nextupf64x (_Float64x __x) throw (); extern _Float64x __nextupf64x (_Float64x __x) throw (); + + + +extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) throw (); + + + +extern _Float64x scalbnf64x (_Float64x __x, int __n) throw (); extern _Float64x __scalbnf64x (_Float64x __x, int __n) throw (); + + + +extern int ilogbf64x (_Float64x __x) throw (); extern int __ilogbf64x (_Float64x __x) throw (); + + + + +extern long int llogbf64x (_Float64x __x) throw (); extern long int __llogbf64x (_Float64x __x) throw (); + + + + +extern _Float64x scalblnf64x (_Float64x __x, long int __n) throw (); extern _Float64x __scalblnf64x (_Float64x __x, long int __n) throw (); + + + +extern _Float64x nearbyintf64x (_Float64x __x) throw (); extern _Float64x __nearbyintf64x (_Float64x __x) throw (); + + + +extern _Float64x roundf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __roundf64x (_Float64x __x) throw () __attribute__ ((__const__)); + + + +extern _Float64x truncf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __truncf64x (_Float64x __x) throw () __attribute__ ((__const__)); + + + + +extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) throw (); extern _Float64x __remquof64x (_Float64x __x, _Float64x __y, int *__quo) throw (); + + + + + + +extern long int lrintf64x (_Float64x __x) throw (); extern long int __lrintf64x (_Float64x __x) throw (); +__extension__ +extern long long int llrintf64x (_Float64x __x) throw (); extern long long int __llrintf64x (_Float64x __x) throw (); + + + +extern long int lroundf64x (_Float64x __x) throw (); extern long int __lroundf64x (_Float64x __x) throw (); +__extension__ +extern long long int llroundf64x (_Float64x __x) throw (); extern long long int __llroundf64x (_Float64x __x) throw (); + + + +extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) throw (); + + +extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fmaxf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); + + +extern _Float64x fminf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fminf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); + + +extern _Float64x fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) throw (); extern _Float64x __fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) throw (); + + + + +extern _Float64x roundevenf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __roundevenf64x (_Float64x __x) throw () __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf64x (_Float64x __x, int __round, unsigned int __width) throw () + ; + + + +extern __uintmax_t ufromfpf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf64x (_Float64x __x, int __round, unsigned int __width) throw () + ; + + + + +extern __intmax_t fromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw () + ; + + + + +extern __uintmax_t ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw () + ; + + +extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fmaxmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); + + +extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fminmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); + + +extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) throw (); + + + + +extern int totalorderf64x (const _Float64x *__x, const _Float64x *__y) throw () + + __attribute__ ((__pure__)); + + +extern int totalordermagf64x (const _Float64x *__x, const _Float64x *__y) throw () + + __attribute__ ((__pure__)); + + +extern _Float64x getpayloadf64x (const _Float64x *__x) throw (); extern _Float64x __getpayloadf64x (const _Float64x *__x) throw (); + + +extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) throw (); + + +extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) throw (); +# 458 "/usr/include/math.h" 2 3 4 +# 503 "/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) throw (); + + +extern float fdiv (double __x, double __y) throw (); + + +extern float fmul (double __x, double __y) throw (); + + +extern float fsub (double __x, double __y) throw (); +# 504 "/usr/include/math.h" 2 3 4 +# 517 "/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) throw (); + + +extern float fdivl (long double __x, long double __y) throw (); + + +extern float fmull (long double __x, long double __y) throw (); + + +extern float fsubl (long double __x, long double __y) throw (); +# 518 "/usr/include/math.h" 2 3 4 +# 537 "/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) throw (); + + +extern double ddivl (long double __x, long double __y) throw (); + + +extern double dmull (long double __x, long double __y) throw (); + + +extern double dsubl (long double __x, long double __y) throw (); +# 538 "/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 _Float32 f32addf32x (_Float32x __x, _Float32x __y) throw (); + + +extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) throw (); + + +extern _Float32 f32mulf32x (_Float32x __x, _Float32x __y) throw (); + + +extern _Float32 f32subf32x (_Float32x __x, _Float32x __y) throw (); +# 617 "/usr/include/math.h" 2 3 4 +# 626 "/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) throw (); + + +extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) throw (); + + +extern _Float32 f32mulf64 (_Float64 __x, _Float64 __y) throw (); + + +extern _Float32 f32subf64 (_Float64 __x, _Float64 __y) throw (); +# 627 "/usr/include/math.h" 2 3 4 +# 636 "/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) throw (); + + +extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) throw (); + + +extern _Float32 f32mulf64x (_Float64x __x, _Float64x __y) throw (); + + +extern _Float32 f32subf64x (_Float64x __x, _Float64x __y) throw (); +# 637 "/usr/include/math.h" 2 3 4 +# 666 "/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) throw (); + + +extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) throw (); + + +extern _Float32x f32xmulf64 (_Float64 __x, _Float64 __y) throw (); + + +extern _Float32x f32xsubf64 (_Float64 __x, _Float64 __y) throw (); +# 667 "/usr/include/math.h" 2 3 4 +# 676 "/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) throw (); + + +extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) throw (); + + +extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) throw (); + + +extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) throw (); +# 677 "/usr/include/math.h" 2 3 4 +# 706 "/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) throw (); + + +extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) throw (); + + +extern _Float64 f64mulf64x (_Float64x __x, _Float64x __y) throw (); + + +extern _Float64 f64subf64x (_Float64x __x, _Float64x __y) throw (); +# 707 "/usr/include/math.h" 2 3 4 +# 773 "/usr/include/math.h" 3 4 +extern int signgam; +# 853 "/usr/include/math.h" 3 4 +enum + { + FP_NAN = + + 0, + FP_INFINITE = + + 1, + FP_ZERO = + + 2, + FP_SUBNORMAL = + + 3, + FP_NORMAL = + + 4 + }; +# 973 "/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) + throw () __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); } + + + +} +# 974 "/usr/include/math.h" 2 3 4 +# 985 "/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); + +} + + + + + +} +# 1016 "/usr/include/math.h" 3 4 +extern "C++" { +# 1047 "/usr/include/math.h" 3 4 +template inline bool +iszero (__T __val) +{ + return __val == 0; +} + +} +# 1278 "/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); + + + + } +}; +# 1321 "/usr/include/math.h" 3 4 +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++/8/cmath" 2 3 +# 77 "/usr/include/c++/8/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++/8/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++/8/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++/8/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); } +# 1888 "/usr/include/c++/8/cmath" 3 + +} + + + + + +} +# 37 "/usr/include/c++/8/math.h" 2 3 4 + +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; +# 8860 "/usr/include/crt/math_functions.h" 2 3 4 +# 1 "/usr/include/c++/8/stdlib.h" 1 3 4 +# 8861 "/usr/include/crt/math_functions.h" 2 3 4 + + +# 1 "/usr/include/c++/8/cmath" 1 3 4 +# 39 "/usr/include/c++/8/cmath" 3 4 + +# 40 "/usr/include/c++/8/cmath" 3 +# 8864 "/usr/include/crt/math_functions.h" 2 3 4 +# 1 "/usr/include/c++/8/cstdlib" 1 3 4 +# 39 "/usr/include/c++/8/cstdlib" 3 4 + +# 40 "/usr/include/c++/8/cstdlib" 3 +# 8865 "/usr/include/crt/math_functions.h" 2 3 4 +# 8934 "/usr/include/crt/math_functions.h" 3 4 +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); +} +# 9098 "/usr/include/crt/math_functions.h" 3 4 +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; +# 9493 "/usr/include/crt/math_functions.h" 3 4 +namespace std { +# 9502 "/usr/include/crt/math_functions.h" 3 4 +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int abs(long long int); +# 9512 "/usr/include/crt/math_functions.h" 3 4 +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); +# 9624 "/usr/include/crt/math_functions.h" 3 4 +} +# 9725 "/usr/include/crt/math_functions.h" 3 4 +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); +} +# 9864 "/usr/include/crt/math_functions.h" 3 4 +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float exp10(float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float rsqrt(float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float rcbrt(float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sinpi(float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cospi(float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void sincospi(float a, float *sptr, float *cptr); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void sincos(float a, float *sptr, float *cptr); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float j0(float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float j1(float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float jn(int n, float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float y0(float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float y1(float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float yn(int n, float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cyl_bessel_i0(float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cyl_bessel_i1(float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfinv(float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfcinv(float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float normcdfinv(float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float normcdf(float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfcx(float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double copysign(double a, float b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double copysign(float a, double b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(unsigned int a, unsigned int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(int a, unsigned int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(unsigned int a, int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int min(long int a, long int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(unsigned long int a, unsigned long int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(long int a, unsigned long int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(unsigned long int a, long int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int min(long long int a, long long int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(unsigned long long int a, unsigned long long int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(long long int a, unsigned long long int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(unsigned long long int a, long long int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float min(float a, float b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(double a, double b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(float a, double b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(double a, float b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(unsigned int a, unsigned int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(int a, unsigned int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(unsigned int a, int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int max(long int a, long int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(unsigned long int a, unsigned long int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(long int a, unsigned long int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(unsigned long int a, long int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int max(long long int a, long long int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(unsigned long long int a, unsigned long long int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(long long int a, unsigned long long int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(unsigned long long int a, long long int b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float max(float a, float b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(double a, double b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(float a, double b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(double a, float b); +# 10255 "/usr/include/crt/math_functions.h" 3 4 +# 1 "/usr/include/crt/math_functions.hpp" 1 3 4 +# 77 "/usr/include/crt/math_functions.hpp" 3 4 +# 1 "/usr/include/builtin_types.h" 1 3 4 +# 78 "/usr/include/crt/math_functions.hpp" 2 3 4 +# 1 "/usr/include/crt/host_defines.h" 1 3 4 +# 79 "/usr/include/crt/math_functions.hpp" 2 3 4 +# 756 "/usr/include/crt/math_functions.hpp" 3 4 +static inline __attribute__((host)) __attribute__((device)) float exp10(float a) +{ + return exp10f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float rsqrt(float a) +{ + return rsqrtf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float rcbrt(float a) +{ + return rcbrtf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float sinpi(float a) +{ + return sinpif(a); +} + +static inline __attribute__((host)) __attribute__((device)) float cospi(float a) +{ + return cospif(a); +} + +static inline __attribute__((host)) __attribute__((device)) void sincospi(float a, float *sptr, float *cptr) +{ + sincospif(a, sptr, cptr); +} + +static inline __attribute__((host)) __attribute__((device)) void sincos(float a, float *sptr, float *cptr) +{ + sincosf(a, sptr, cptr); +} + +static inline __attribute__((host)) __attribute__((device)) float j0(float a) +{ + return j0f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float j1(float a) +{ + return j1f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float jn(int n, float a) +{ + return jnf(n, a); +} + +static inline __attribute__((host)) __attribute__((device)) float y0(float a) +{ + return y0f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float y1(float a) +{ + return y1f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float yn(int n, float a) +{ + return ynf(n, a); +} + +static inline __attribute__((host)) __attribute__((device)) float cyl_bessel_i0(float a) +{ + return cyl_bessel_i0f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float cyl_bessel_i1(float a) +{ + return cyl_bessel_i1f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float erfinv(float a) +{ + return erfinvf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float erfcinv(float a) +{ + return erfcinvf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float normcdfinv(float a) +{ + return normcdfinvf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float normcdf(float a) +{ + return normcdff(a); +} + +static inline __attribute__((host)) __attribute__((device)) float erfcx(float a) +{ + return erfcxf(a); +} + +static inline __attribute__((host)) __attribute__((device)) double copysign(double a, float b) +{ + return copysign(a, (double)b); +} + +static inline __attribute__((host)) __attribute__((device)) double copysign(float a, double b) +{ + return copysign((double)a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int min(unsigned int a, unsigned int b) +{ + return umin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int min(int a, unsigned int b) +{ + return umin((unsigned int)a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int min(unsigned int a, int b) +{ + return umin(a, (unsigned int)b); +} + +static inline __attribute__((host)) __attribute__((device)) long int min(long int a, long int b) +{ + + + + + + if (sizeof(long int) == sizeof(int)) { + + + + return (long int)min((int)a, (int)b); + } else { + return (long int)llmin((long long int)a, (long long int)b); + } +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int min(unsigned long int a, unsigned long int b) +{ + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + return (unsigned long int)umin((unsigned int)a, (unsigned int)b); + } else { + return (unsigned long int)ullmin((unsigned long long int)a, (unsigned long long int)b); + } +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int min(long int a, unsigned long int b) +{ + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + return (unsigned long int)umin((unsigned int)a, (unsigned int)b); + } else { + return (unsigned long int)ullmin((unsigned long long int)a, (unsigned long long int)b); + } +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int min(unsigned long int a, long int b) +{ + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + return (unsigned long int)umin((unsigned int)a, (unsigned int)b); + } else { + return (unsigned long int)ullmin((unsigned long long int)a, (unsigned long long int)b); + } +} + +static inline __attribute__((host)) __attribute__((device)) long long int min(long long int a, long long int b) +{ + return llmin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(unsigned long long int a, unsigned long long int b) +{ + return ullmin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(long long int a, unsigned long long int b) +{ + return ullmin((unsigned long long int)a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(unsigned long long int a, long long int b) +{ + return ullmin(a, (unsigned long long int)b); +} + +static inline __attribute__((host)) __attribute__((device)) float min(float a, float b) +{ + return fminf(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double min(double a, double b) +{ + return fmin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double min(float a, double b) +{ + return fmin((double)a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double min(double a, float b) +{ + return fmin(a, (double)b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int max(unsigned int a, unsigned int b) +{ + return umax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int max(int a, unsigned int b) +{ + return umax((unsigned int)a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int max(unsigned int a, int b) +{ + return umax(a, (unsigned int)b); +} + +static inline __attribute__((host)) __attribute__((device)) long int max(long int a, long int b) +{ + + + + + if (sizeof(long int) == sizeof(int)) { + + + + return (long int)max((int)a, (int)b); + } else { + return (long int)llmax((long long int)a, (long long int)b); + } +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int max(unsigned long int a, unsigned long int b) +{ + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + return (unsigned long int)umax((unsigned int)a, (unsigned int)b); + } else { + return (unsigned long int)ullmax((unsigned long long int)a, (unsigned long long int)b); + } +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int max(long int a, unsigned long int b) +{ + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + return (unsigned long int)umax((unsigned int)a, (unsigned int)b); + } else { + return (unsigned long int)ullmax((unsigned long long int)a, (unsigned long long int)b); + } +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int max(unsigned long int a, long int b) +{ + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + return (unsigned long int)umax((unsigned int)a, (unsigned int)b); + } else { + return (unsigned long int)ullmax((unsigned long long int)a, (unsigned long long int)b); + } +} + +static inline __attribute__((host)) __attribute__((device)) long long int max(long long int a, long long int b) +{ + return llmax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(unsigned long long int a, unsigned long long int b) +{ + return ullmax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(long long int a, unsigned long long int b) +{ + return ullmax((unsigned long long int)a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(unsigned long long int a, long long int b) +{ + return ullmax(a, (unsigned long long int)b); +} + +static inline __attribute__((host)) __attribute__((device)) float max(float a, float b) +{ + return fmaxf(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double max(double a, double b) +{ + return fmax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double max(float a, double b) +{ + return fmax((double)a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double max(double a, float b) +{ + return fmax(a, (double)b); +} +# 10256 "/usr/include/crt/math_functions.h" 2 3 4 +# 268 "/usr/include/crt/common_functions.h" 2 3 4 +# 116 "/usr/include/cuda_runtime.h" 2 3 4 +# 1 "/usr/include/cuda_surface_types.h" 1 3 4 +# 74 "/usr/include/cuda_surface_types.h" 3 4 +template +struct __attribute__((device_builtin_surface_type)) surface : public surfaceReference +{ + + __attribute__((host)) surface(void) + { + channelDesc = cudaCreateChannelDesc(); + } + + __attribute__((host)) surface(struct cudaChannelFormatDesc desc) + { + channelDesc = desc; + } + +}; + +template +struct __attribute__((device_builtin_surface_type)) surface : public surfaceReference +{ + + __attribute__((host)) surface(void) + { + channelDesc = cudaCreateChannelDesc(); + } + +}; +# 117 "/usr/include/cuda_runtime.h" 2 3 4 +# 1 "/usr/include/cuda_texture_types.h" 1 3 4 +# 74 "/usr/include/cuda_texture_types.h" 3 4 +template +struct __attribute__((device_builtin_texture_type)) texture : public textureReference +{ + + __attribute__((host)) texture(int norm = 0, + enum cudaTextureFilterMode fMode = cudaFilterModePoint, + enum cudaTextureAddressMode aMode = cudaAddressModeClamp) + { + normalized = norm; + filterMode = fMode; + addressMode[0] = aMode; + addressMode[1] = aMode; + addressMode[2] = aMode; + channelDesc = cudaCreateChannelDesc(); + sRGB = 0; + } + + __attribute__((host)) texture(int norm, + enum cudaTextureFilterMode fMode, + enum cudaTextureAddressMode aMode, + struct cudaChannelFormatDesc desc) + { + normalized = norm; + filterMode = fMode; + addressMode[0] = aMode; + addressMode[1] = aMode; + addressMode[2] = aMode; + channelDesc = desc; + sRGB = 0; + } + +}; +# 118 "/usr/include/cuda_runtime.h" 2 3 4 +# 1 "/usr/include/crt/device_functions.h" 1 3 4 +# 79 "/usr/include/crt/device_functions.h" 3 4 +# 1 "/usr/include/builtin_types.h" 1 3 4 +# 80 "/usr/include/crt/device_functions.h" 2 3 4 +# 1 "/usr/include/device_types.h" 1 3 4 +# 81 "/usr/include/crt/device_functions.h" 2 3 4 +# 1 "/usr/include/crt/host_defines.h" 1 3 4 +# 82 "/usr/include/crt/device_functions.h" 2 3 4 + + + + + + + +extern "C" +{ +# 100 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __mulhi(int x, int y); +# 110 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __umulhi(unsigned int x, unsigned int y); +# 120 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __mul64hi(long long int x, long long int y); +# 130 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __umul64hi(unsigned long long int x, unsigned long long int y); +# 139 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int_as_float(int x); +# 148 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float_as_int(float x); +# 157 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint_as_float(unsigned int x); +# 166 "/usr/include/crt/device_functions.h" 3 4 +__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(); +# 201 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __saturatef(float x); +# 270 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __sad(int x, int y, unsigned int z); +# 338 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __usad(unsigned int x, unsigned int y, unsigned int z); +# 348 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __mul24(int x, int y); +# 358 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __umul24(unsigned int x, unsigned int y); +# 371 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float fdividef(float x, float y); +# 446 "/usr/include/crt/device_functions.h" 3 4 +__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); +# 459 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __sinf(float x) throw (); +# 471 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __cosf(float x) throw (); +# 485 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __tanf(float x) throw (); +# 500 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void __sincosf(float x, float *sptr, float *cptr) throw (); +# 550 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __expf(float x) throw (); +# 582 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __exp10f(float x) throw (); +# 608 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log2f(float x) throw (); +# 636 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log10f(float x) throw (); +# 680 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __logf(float x) throw (); +# 723 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __powf(float x, float y) throw (); +# 732 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rn(float x); +# 741 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rz(float x); +# 750 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_ru(float); +# 759 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rd(float x); +# 768 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rn(float x); +# 777 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rz(float x); +# 786 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_ru(float x); +# 795 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rd(float x); +# 804 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rn(int x); +# 813 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rz(int x); +# 822 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_ru(int x); +# 831 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rd(int x); +# 840 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rn(unsigned int x); +# 849 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rz(unsigned int x); +# 858 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_ru(unsigned int x); +# 867 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rd(unsigned int x); +# 876 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rn(float x); +# 885 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rz(float x); +# 894 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_ru(float x); +# 903 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rd(float x); +# 912 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rn(float x); +# 921 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rz(float x); +# 930 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_ru(float x); +# 939 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rd(float x); +# 948 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rn(long long int x); +# 957 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rz(long long int x); +# 966 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_ru(long long int x); +# 975 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rd(long long int x); +# 984 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rn(unsigned long long int x); +# 993 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rz(unsigned long long int x); +# 1002 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_ru(unsigned long long int x); +# 1011 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rd(unsigned long long int x); +# 1023 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rn(float x, float y); +# 1035 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rz(float x, float y); +# 1047 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_ru(float x, float y); +# 1059 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rd(float x, float y); +# 1071 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rn(float x, float y); +# 1083 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rz(float x, float y); +# 1095 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_ru(float x, float y); +# 1107 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rd(float x, float y); +# 1119 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rn(float x, float y); +# 1131 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rz(float x, float y); +# 1143 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_ru(float x, float y); +# 1155 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rd(float x, float y); +# 1308 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rn(float x, float y, float z); +# 1461 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rz(float x, float y, float z); +# 1614 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_ru(float x, float y, float z); +# 1767 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rd(float x, float y, float z); +# 1800 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rn(float x); +# 1833 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rz(float x); +# 1866 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_ru(float x); +# 1899 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rd(float x); +# 1930 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rn(float x); +# 1961 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rz(float x); +# 1992 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_ru(float x); +# 2023 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rd(float x); +# 2062 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frsqrt_rn(float x); +# 2073 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rn(float x, float y); +# 2084 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rz(float x, float y); +# 2095 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_ru(float x, float y); +# 2106 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rd(float x, float y); +# 2115 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __clz(int x); +# 2126 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __ffs(int x); +# 2135 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __popc(unsigned int x); +# 2144 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __brev(unsigned int x); +# 2153 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __clzll(long long int x); +# 2164 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __ffsll(long long int x); +# 2175 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __popcll(unsigned long long int x); +# 2184 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __brevll(unsigned long long int x); +# 2208 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __byte_perm(unsigned int x, unsigned int y, unsigned int s); +# 2220 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __hadd(int, int); +# 2233 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __rhadd(int, int); +# 2245 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __uhadd(unsigned int, unsigned int); +# 2258 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __urhadd(unsigned int, unsigned int); +# 2268 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __double2int_rz(double); +# 2277 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __double2uint_rz(double); +# 2286 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __double2ll_rz(double); +# 2295 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __double2ull_rz(double); +__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); +# 2325 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabs2(unsigned int a); +# 2336 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsss2(unsigned int a); +# 2347 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vadd2(unsigned int a, unsigned int b); +# 2358 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddss2 (unsigned int a, unsigned int b); +# 2368 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddus2 (unsigned int a, unsigned int b); +# 2379 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgs2(unsigned int a, unsigned int b); +# 2390 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgu2(unsigned int a, unsigned int b); +# 2401 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vhaddu2(unsigned int a, unsigned int b); +# 2412 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpeq2(unsigned int a, unsigned int b); +# 2423 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpges2(unsigned int a, unsigned int b); +# 2434 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgeu2(unsigned int a, unsigned int b); +# 2445 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgts2(unsigned int a, unsigned int b); +# 2456 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgtu2(unsigned int a, unsigned int b); +# 2467 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmples2(unsigned int a, unsigned int b); +# 2479 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpleu2(unsigned int a, unsigned int b); +# 2490 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmplts2(unsigned int a, unsigned int b); +# 2501 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpltu2(unsigned int a, unsigned int b); +# 2512 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpne2(unsigned int a, unsigned int b); +# 2523 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffu2(unsigned int a, unsigned int b); +# 2534 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxs2(unsigned int a, unsigned int b); +# 2545 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxu2(unsigned int a, unsigned int b); +# 2556 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmins2(unsigned int a, unsigned int b); +# 2567 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vminu2(unsigned int a, unsigned int b); +# 2578 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vseteq2(unsigned int a, unsigned int b); +# 2589 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetges2(unsigned int a, unsigned int b); +# 2600 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgeu2(unsigned int a, unsigned int b); +# 2611 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgts2(unsigned int a, unsigned int b); +# 2622 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgtu2(unsigned int a, unsigned int b); +# 2633 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetles2(unsigned int a, unsigned int b); +# 2644 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetleu2(unsigned int a, unsigned int b); +# 2655 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetlts2(unsigned int a, unsigned int b); +# 2666 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetltu2(unsigned int a, unsigned int b); +# 2677 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetne2(unsigned int a, unsigned int b); +# 2688 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsadu2(unsigned int a, unsigned int b); +# 2699 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsub2(unsigned int a, unsigned int b); +# 2710 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubss2 (unsigned int a, unsigned int b); +# 2721 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubus2 (unsigned int a, unsigned int b); +# 2731 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vneg2(unsigned int a); +# 2741 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vnegss2(unsigned int a); +# 2752 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffs2(unsigned int a, unsigned int b); +# 2763 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsads2(unsigned int a, unsigned int b); +# 2773 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabs4(unsigned int a); +# 2784 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsss4(unsigned int a); +# 2795 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vadd4(unsigned int a, unsigned int b); +# 2806 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddss4 (unsigned int a, unsigned int b); +# 2816 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddus4 (unsigned int a, unsigned int b); +# 2827 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgs4(unsigned int a, unsigned int b); +# 2838 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgu4(unsigned int a, unsigned int b); +# 2849 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vhaddu4(unsigned int a, unsigned int b); +# 2860 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpeq4(unsigned int a, unsigned int b); +# 2871 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpges4(unsigned int a, unsigned int b); +# 2882 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgeu4(unsigned int a, unsigned int b); +# 2893 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgts4(unsigned int a, unsigned int b); +# 2904 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgtu4(unsigned int a, unsigned int b); +# 2915 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmples4(unsigned int a, unsigned int b); +# 2926 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpleu4(unsigned int a, unsigned int b); +# 2937 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmplts4(unsigned int a, unsigned int b); +# 2948 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpltu4(unsigned int a, unsigned int b); +# 2959 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpne4(unsigned int a, unsigned int b); +# 2970 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffu4(unsigned int a, unsigned int b); +# 2981 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxs4(unsigned int a, unsigned int b); +# 2992 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxu4(unsigned int a, unsigned int b); +# 3003 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmins4(unsigned int a, unsigned int b); +# 3014 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vminu4(unsigned int a, unsigned int b); +# 3025 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vseteq4(unsigned int a, unsigned int b); +# 3036 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetles4(unsigned int a, unsigned int b); +# 3047 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetleu4(unsigned int a, unsigned int b); +# 3058 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetlts4(unsigned int a, unsigned int b); +# 3069 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetltu4(unsigned int a, unsigned int b); +# 3080 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetges4(unsigned int a, unsigned int b); +# 3091 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgeu4(unsigned int a, unsigned int b); +# 3102 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgts4(unsigned int a, unsigned int b); +# 3113 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgtu4(unsigned int a, unsigned int b); +# 3124 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetne4(unsigned int a, unsigned int b); +# 3135 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsadu4(unsigned int a, unsigned int b); +# 3146 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsub4(unsigned int a, unsigned int b); +# 3157 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubss4(unsigned int a, unsigned int b); +# 3168 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubus4(unsigned int a, unsigned int b); +# 3178 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vneg4(unsigned int a); +# 3188 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vnegss4(unsigned int a); +# 3199 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffs4(unsigned int a, unsigned int b); +# 3210 "/usr/include/crt/device_functions.h" 3 4 +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsads4(unsigned int a, unsigned int b); + + + + + + +} + + + + + + + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) int mulhi(int a, int b); + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) unsigned int mulhi(unsigned int a, unsigned int b); + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) unsigned int mulhi(int a, unsigned int b); + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) unsigned int mulhi(unsigned int a, int b); + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) long long int mul64hi(long long int a, long long int b); + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int mul64hi(unsigned long long int a, unsigned long long int b); + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int mul64hi(long long int a, unsigned long long int b); + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int mul64hi(unsigned long long int a, long long int b); + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) int float_as_int(float a); + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) float int_as_float(int a); + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) unsigned int float_as_uint(float a); + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) float uint_as_float(unsigned int a); + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) float saturate(float a); + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) int mul24(int a, int b); + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) unsigned int umul24(unsigned int a, unsigned int b); + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) int float2int(float a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) unsigned int float2uint(float a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) float int2float(int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) float uint2float(unsigned int a, enum cudaRoundMode mode = cudaRoundNearest); +# 3275 "/usr/include/crt/device_functions.h" 3 4 +# 1 "/usr/include/crt/device_functions.hpp" 1 3 4 +# 79 "/usr/include/crt/device_functions.hpp" 3 4 +# 1 "/usr/include/builtin_types.h" 1 3 4 +# 80 "/usr/include/crt/device_functions.hpp" 2 3 4 + +# 1 "/usr/include/crt/host_defines.h" 1 3 4 +# 82 "/usr/include/crt/device_functions.hpp" 2 3 4 +# 90 "/usr/include/crt/device_functions.hpp" 3 4 +static __inline__ __attribute__((device)) int mulhi(int a, int b) +{ + return __mulhi(a, b); +} + +static __inline__ __attribute__((device)) unsigned int mulhi(unsigned int a, unsigned int b) +{ + return __umulhi(a, b); +} + +static __inline__ __attribute__((device)) unsigned int mulhi(int a, unsigned int b) +{ + return __umulhi((unsigned int)a, b); +} + +static __inline__ __attribute__((device)) unsigned int mulhi(unsigned int a, int b) +{ + return __umulhi(a, (unsigned int)b); +} + +static __inline__ __attribute__((device)) long long int mul64hi(long long int a, long long int b) +{ + return __mul64hi(a, b); +} + +static __inline__ __attribute__((device)) unsigned long long int mul64hi(unsigned long long int a, unsigned long long int b) +{ + return __umul64hi(a, b); +} + +static __inline__ __attribute__((device)) unsigned long long int mul64hi(long long int a, unsigned long long int b) +{ + return __umul64hi((unsigned long long int)a, b); +} + +static __inline__ __attribute__((device)) unsigned long long int mul64hi(unsigned long long int a, long long int b) +{ + return __umul64hi(a, (unsigned long long int)b); +} + +static __inline__ __attribute__((device)) int float_as_int(float a) +{ + return __float_as_int(a); +} + +static __inline__ __attribute__((device)) float int_as_float(int a) +{ + return __int_as_float(a); +} + +static __inline__ __attribute__((device)) unsigned int float_as_uint(float a) +{ + return __float_as_uint(a); +} + +static __inline__ __attribute__((device)) float uint_as_float(unsigned int a) +{ + return __uint_as_float(a); +} +static __inline__ __attribute__((device)) float saturate(float a) +{ + return __saturatef(a); +} + +static __inline__ __attribute__((device)) int mul24(int a, int b) +{ + return __mul24(a, b); +} + +static __inline__ __attribute__((device)) unsigned int umul24(unsigned int a, unsigned int b) +{ + return __umul24(a, b); +} + +static __inline__ __attribute__((device)) int float2int(float a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __float2int_rn(a) : + mode == cudaRoundPosInf ? __float2int_ru(a) : + mode == cudaRoundMinInf ? __float2int_rd(a) : + __float2int_rz(a); +} + +static __inline__ __attribute__((device)) unsigned int float2uint(float a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __float2uint_rn(a) : + mode == cudaRoundPosInf ? __float2uint_ru(a) : + mode == cudaRoundMinInf ? __float2uint_rd(a) : + __float2uint_rz(a); +} + +static __inline__ __attribute__((device)) float int2float(int a, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __int2float_rz(a) : + mode == cudaRoundPosInf ? __int2float_ru(a) : + mode == cudaRoundMinInf ? __int2float_rd(a) : + __int2float_rn(a); +} + +static __inline__ __attribute__((device)) float uint2float(unsigned int a, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __uint2float_rz(a) : + mode == cudaRoundPosInf ? __uint2float_ru(a) : + mode == cudaRoundMinInf ? __uint2float_rd(a) : + __uint2float_rn(a); +} +# 3276 "/usr/include/crt/device_functions.h" 2 3 4 + + +# 1 "/usr/include/device_atomic_functions.h" 1 3 4 +# 76 "/usr/include/device_atomic_functions.h" 3 4 +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); +} +# 106 "/usr/include/device_atomic_functions.h" 3 4 +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) ; +# 171 "/usr/include/device_atomic_functions.h" 3 4 +extern "C" +{ + +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); + +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); +} +# 189 "/usr/include/device_atomic_functions.h" 3 4 +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) ; +# 208 "/usr/include/device_atomic_functions.h" 3 4 +# 1 "/usr/include/device_atomic_functions.hpp" 1 3 4 +# 75 "/usr/include/device_atomic_functions.hpp" 3 4 +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); +} +# 194 "/usr/include/device_atomic_functions.hpp" 3 4 +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); +} +# 209 "/usr/include/device_atomic_functions.h" 2 3 4 +# 3279 "/usr/include/crt/device_functions.h" 2 3 4 +# 1 "/usr/include/crt/device_double_functions.h" 1 3 4 +# 83 "/usr/include/crt/device_double_functions.h" 3 4 +# 1 "/usr/include/builtin_types.h" 1 3 4 +# 84 "/usr/include/crt/device_double_functions.h" 2 3 4 + +# 1 "/usr/include/crt/host_defines.h" 1 3 4 +# 86 "/usr/include/crt/device_double_functions.h" 2 3 4 + +extern "C" +{ +# 97 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double_as_longlong(double x); +# 106 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __longlong_as_double(long long int x); +# 263 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rn(double x, double y, double z); +# 420 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rz(double x, double y, double z); +# 577 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_ru(double x, double y, double z); +# 734 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rd(double x, double y, double z); +# 746 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rn(double x, double y); +# 758 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rz(double x, double y); +# 770 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_ru(double x, double y); +# 782 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rd(double x, double y); +# 794 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rn(double x, double y); +# 806 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rz(double x, double y); +# 818 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_ru(double x, double y); +# 830 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rd(double x, double y); +# 842 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rn(double x, double y); +# 854 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rz(double x, double y); +# 866 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_ru(double x, double y); +# 878 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rd(double x, double y); +# 887 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rn(double x); +# 896 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rz(double x); +# 905 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_ru(double x); +# 914 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rd(double x); +# 923 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rn(double x); +# 932 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_ru(double x); +# 941 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rd(double x); +# 950 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rn(double x); +# 959 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_ru(double x); +# 968 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rd(double x); +# 977 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rn(double x); +# 986 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_ru(double x); +# 995 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rd(double x); +# 1004 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rn(double x); +# 1013 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_ru(double x); +# 1022 "/usr/include/crt/device_double_functions.h" 3 4 +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); +# 1047 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rn(long long int x); +# 1056 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rz(long long int x); +# 1065 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_ru(long long int x); +# 1074 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rd(long long int x); +# 1083 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rn(unsigned long long int x); +# 1092 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rz(unsigned long long int x); +# 1101 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_ru(unsigned long long int x); +# 1110 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rd(unsigned long long int x); +# 1119 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) int __double2hiint(double x); +# 1128 "/usr/include/crt/device_double_functions.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) int __double2loint(double x); +# 1138 "/usr/include/crt/device_double_functions.h" 3 4 +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 "/usr/include/crt/device_double_functions.hpp" 1 3 4 +# 83 "/usr/include/crt/device_double_functions.hpp" 3 4 +# 1 "/usr/include/builtin_types.h" 1 3 4 +# 84 "/usr/include/crt/device_double_functions.hpp" 2 3 4 + +# 1 "/usr/include/crt/host_defines.h" 1 3 4 +# 86 "/usr/include/crt/device_double_functions.hpp" 2 3 4 + + + + + + + +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; +} +# 1179 "/usr/include/crt/device_double_functions.h" 2 3 4 +# 3280 "/usr/include/crt/device_functions.h" 2 3 4 +# 1 "/usr/include/sm_20_atomic_functions.h" 1 3 4 +# 77 "/usr/include/sm_20_atomic_functions.h" 3 4 +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) float __fAtomicAdd(float *address, float val); +} +# 89 "/usr/include/sm_20_atomic_functions.h" 3 4 +static __inline__ __attribute__((device)) float atomicAdd(float *address, float val) ; + + + + + + + +# 1 "/usr/include/sm_20_atomic_functions.hpp" 1 3 4 +# 75 "/usr/include/sm_20_atomic_functions.hpp" 3 4 +static __inline__ __attribute__((device)) float atomicAdd(float *address, float val) +{ + return __fAtomicAdd(address, val); +} +# 98 "/usr/include/sm_20_atomic_functions.h" 2 3 4 +# 3281 "/usr/include/crt/device_functions.h" 2 3 4 +# 1 "/usr/include/sm_32_atomic_functions.h" 1 3 4 +# 128 "/usr/include/sm_32_atomic_functions.h" 3 4 +# 1 "/usr/include/sm_32_atomic_functions.hpp" 1 3 4 +# 129 "/usr/include/sm_32_atomic_functions.h" 2 3 4 +# 3282 "/usr/include/crt/device_functions.h" 2 3 4 +# 1 "/usr/include/sm_35_atomic_functions.h" 1 3 4 +# 56 "/usr/include/sm_35_atomic_functions.h" 3 4 +# 1 "/usr/include/sm_32_atomic_functions.h" 1 3 4 +# 57 "/usr/include/sm_35_atomic_functions.h" 2 3 4 +# 3283 "/usr/include/crt/device_functions.h" 2 3 4 +# 1 "/usr/include/sm_60_atomic_functions.h" 1 3 4 +# 535 "/usr/include/sm_60_atomic_functions.h" 3 4 +# 1 "/usr/include/sm_60_atomic_functions.hpp" 1 3 4 +# 536 "/usr/include/sm_60_atomic_functions.h" 2 3 4 +# 3284 "/usr/include/crt/device_functions.h" 2 3 4 +# 1 "/usr/include/sm_20_intrinsics.h" 1 3 4 +# 90 "/usr/include/sm_20_intrinsics.h" 3 4 +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) void __threadfence_system(void); +# 104 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rn(double x, double y); +# 116 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rz(double x, double y); +# 128 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_ru(double x, double y); +# 140 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rd(double x, double y); +# 174 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rn(double x); +# 208 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rz(double x); +# 242 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_ru(double x); +# 276 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rd(double x); +# 308 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rn(double x); +# 340 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rz(double x); +# 372 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_ru(double x); +# 404 "/usr/include/sm_20_intrinsics.h" 3 4 +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); + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rn(float, float, float); +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rz(float, float, float); +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_ru(float, float, float); +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rd(float, float, float); +# 431 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double_as_longlong(double x); +# 440 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __longlong_as_double(long long int x); +# 597 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rn(double x, double y, double z); +# 754 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rz(double x, double y, double z); +# 911 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_ru(double x, double y, double z); +# 1068 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rd(double x, double y, double z); +# 1080 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rn(double x, double y); +# 1092 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rz(double x, double y); +# 1104 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_ru(double x, double y); +# 1116 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rd(double x, double y); +# 1128 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rn(double x, double y); +# 1140 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rz(double x, double y); +# 1152 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_ru(double x, double y); +# 1164 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rd(double x, double y); +# 1176 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rn(double x, double y); +# 1188 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rz(double x, double y); +# 1200 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_ru(double x, double y); +# 1212 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rd(double x, double y); +# 1221 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rn(double x); +# 1230 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rz(double x); +# 1239 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_ru(double x); +# 1248 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rd(double x); +# 1257 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rn(double x); +# 1266 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_ru(double x); +# 1275 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rd(double x); +# 1284 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rn(double x); +# 1293 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_ru(double x); +# 1302 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rd(double x); +# 1311 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rn(double x); +# 1320 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_ru(double x); +# 1329 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rd(double x); +# 1338 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rn(double x); +# 1347 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_ru(double x); +# 1356 "/usr/include/sm_20_intrinsics.h" 3 4 +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); +# 1381 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rn(long long int x); +# 1390 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rz(long long int x); +# 1399 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_ru(long long int x); +# 1408 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rd(long long int x); +# 1417 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rn(unsigned long long int x); +# 1426 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rz(unsigned long long int x); +# 1435 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_ru(unsigned long long int x); +# 1444 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rd(unsigned long long int x); +# 1453 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) int __double2hiint(double x); +# 1462 "/usr/include/sm_20_intrinsics.h" 3 4 +extern __attribute__((device)) __attribute__((device_builtin)) int __double2loint(double x); +# 1472 "/usr/include/sm_20_intrinsics.h" 3 4 +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) ; + + + + + + + +# 1 "/usr/include/sm_20_intrinsics.hpp" 1 3 4 +# 75 "/usr/include/sm_20_intrinsics.hpp" 3 4 +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 *); +extern "C" __attribute__((device)) unsigned __nv_isShared_impl(const void *); +extern "C" __attribute__((device)) unsigned __nv_isConstant_impl(const void *); +extern "C" __attribute__((device)) unsigned __nv_isLocal_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); +} +# 1505 "/usr/include/sm_20_intrinsics.h" 2 3 4 +# 3285 "/usr/include/crt/device_functions.h" 2 3 4 +# 1 "/usr/include/sm_30_intrinsics.h" 1 3 4 +# 102 "/usr/include/sm_30_intrinsics.h" 3 4 +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() ; +# 119 "/usr/include/sm_30_intrinsics.h" 3 4 +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) ; +# 212 "/usr/include/sm_30_intrinsics.h" 3 4 +# 1 "/usr/include/sm_30_intrinsics.hpp" 1 3 4 +# 73 "/usr/include/sm_30_intrinsics.hpp" 3 4 +extern "C" +{ +} +# 89 "/usr/include/sm_30_intrinsics.hpp" 3 4 +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 "/usr/include/sm_30_intrinsics.hpp" 3 4 +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); +} +# 213 "/usr/include/sm_30_intrinsics.h" 2 3 4 +# 3286 "/usr/include/crt/device_functions.h" 2 3 4 +# 1 "/usr/include/sm_32_intrinsics.h" 1 3 4 +# 291 "/usr/include/sm_32_intrinsics.h" 3 4 +# 1 "/usr/include/sm_32_intrinsics.hpp" 1 3 4 +# 292 "/usr/include/sm_32_intrinsics.h" 2 3 4 +# 3287 "/usr/include/crt/device_functions.h" 2 3 4 +# 1 "/usr/include/sm_35_intrinsics.h" 1 3 4 +# 111 "/usr/include/sm_35_intrinsics.h" 3 4 +# 1 "/usr/include/sm_32_intrinsics.h" 1 3 4 +# 112 "/usr/include/sm_35_intrinsics.h" 2 3 4 +# 3288 "/usr/include/crt/device_functions.h" 2 3 4 +# 1 "/usr/include/sm_61_intrinsics.h" 1 3 4 +# 120 "/usr/include/sm_61_intrinsics.h" 3 4 +# 1 "/usr/include/sm_61_intrinsics.hpp" 1 3 4 +# 121 "/usr/include/sm_61_intrinsics.h" 2 3 4 +# 3289 "/usr/include/crt/device_functions.h" 2 3 4 +# 1 "/usr/include/crt/sm_70_rt.h" 1 3 4 +# 123 "/usr/include/crt/sm_70_rt.h" 3 4 +# 1 "/usr/include/crt/sm_70_rt.hpp" 1 3 4 +# 124 "/usr/include/crt/sm_70_rt.h" 2 3 4 +# 3290 "/usr/include/crt/device_functions.h" 2 3 4 +# 1 "/usr/include/surface_functions.h" 1 3 4 +# 65 "/usr/include/surface_functions.h" 3 4 +template struct __nv_surf_trait { typedef void * cast_type; }; + +template<> struct __nv_surf_trait { typedef char * cast_type; }; +template<> struct __nv_surf_trait { typedef signed char * cast_type; }; +template<> struct __nv_surf_trait { typedef unsigned char * cast_type; }; +template<> struct __nv_surf_trait { typedef char1 * cast_type; }; +template<> struct __nv_surf_trait { typedef uchar1 * cast_type; }; +template<> struct __nv_surf_trait { typedef char2 * cast_type; }; +template<> struct __nv_surf_trait { typedef uchar2 * cast_type; }; +template<> struct __nv_surf_trait { typedef char4 * cast_type; }; +template<> struct __nv_surf_trait { typedef uchar4 * cast_type; }; +template<> struct __nv_surf_trait { typedef short * cast_type; }; +template<> struct __nv_surf_trait { typedef unsigned short * cast_type; }; +template<> struct __nv_surf_trait { typedef short1 * cast_type; }; +template<> struct __nv_surf_trait { typedef ushort1 * cast_type; }; +template<> struct __nv_surf_trait { typedef short2 * cast_type; }; +template<> struct __nv_surf_trait { typedef ushort2 * cast_type; }; +template<> struct __nv_surf_trait { typedef short4 * cast_type; }; +template<> struct __nv_surf_trait { typedef ushort4 * cast_type; }; +template<> struct __nv_surf_trait { typedef int * cast_type; }; +template<> struct __nv_surf_trait { typedef unsigned int * cast_type; }; +template<> struct __nv_surf_trait { typedef int1 * cast_type; }; +template<> struct __nv_surf_trait { typedef uint1 * cast_type; }; +template<> struct __nv_surf_trait { typedef int2 * cast_type; }; +template<> struct __nv_surf_trait { typedef uint2 * cast_type; }; +template<> struct __nv_surf_trait { typedef int4 * cast_type; }; +template<> struct __nv_surf_trait { typedef uint4 * cast_type; }; +template<> struct __nv_surf_trait { typedef long long * cast_type; }; +template<> struct __nv_surf_trait { typedef unsigned long long * cast_type; }; +template<> struct __nv_surf_trait { typedef longlong1 * cast_type; }; +template<> struct __nv_surf_trait { typedef ulonglong1 * cast_type; }; +template<> struct __nv_surf_trait { typedef longlong2 * cast_type; }; +template<> struct __nv_surf_trait { typedef ulonglong2 * cast_type; }; +# 108 "/usr/include/surface_functions.h" 3 4 +template<> struct __nv_surf_trait { typedef float * cast_type; }; +template<> struct __nv_surf_trait { typedef float1 * cast_type; }; +template<> struct __nv_surf_trait { typedef float2 * cast_type; }; +template<> struct __nv_surf_trait { typedef float4 * cast_type; }; + + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf1Dread(T *res, surface surf, int x, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surf1Dread_v2", (void *)res, s, surf, x, mode); + +} + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) T surf1Dread(surface surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + T temp; + __nv_tex_surf_handler("__surf1Dread_v2", (typename __nv_surf_trait::cast_type)&temp, (int)sizeof(T), surf, x, mode); + return temp; + +} + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf1Dread(T *res, surface surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + *res = surf1Dread(surf, x, mode); + +} + + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf2Dread(T *res, surface surf, int x, int y, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surf2Dread_v2", (void *)res, s, surf, x, y, mode); + +} + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) T surf2Dread(surface surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + T temp; + __nv_tex_surf_handler("__surf2Dread_v2", (typename __nv_surf_trait::cast_type)&temp, (int)sizeof(T), surf, x, y, mode); + return temp; + +} + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf2Dread(T *res, surface surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + *res = surf2Dread(surf, x, y, mode); + +} + + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf3Dread(T *res, surface surf, int x, int y, int z, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surf3Dread_v2", (void *)res, s, surf, x, y, z, mode); + +} + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) T surf3Dread(surface surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + T temp; + __nv_tex_surf_handler("__surf3Dread_v2", (typename __nv_surf_trait::cast_type)&temp, (int)sizeof(T), surf, x, y, z, mode); + return temp; + +} + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf3Dread(T *res, surface surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + *res = surf3Dread(surf, x, y, z, mode); + +} + + + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf1DLayeredread(T *res, surface surf, int x, int layer, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surf1DLayeredread_v2", (void *)res, s, surf, x, layer, mode); + +} + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) T surf1DLayeredread(surface surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + T temp; + __nv_tex_surf_handler("__surf1DLayeredread_v2", (typename __nv_surf_trait::cast_type)&temp, (int)sizeof(T), surf, x, layer, mode); + return temp; + +} + + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf1DLayeredread(T *res, surface surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + *res = surf1DLayeredread(surf, x, layer, mode); + +} + + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf2DLayeredread(T *res, surface surf, int x, int y, int layer, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surf2DLayeredread_v2", (void *)res, s, surf, x, y, layer, mode); + +} + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) T surf2DLayeredread(surface surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + T temp; + __nv_tex_surf_handler("__surf2DLayeredread_v2", (typename __nv_surf_trait::cast_type)&temp, (int)sizeof(T), surf, x, y, layer, mode); + return temp; + +} + + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf2DLayeredread(T *res, surface surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + *res = surf2DLayeredread(surf, x, y, layer, mode); + +} + + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surfCubemapread(T *res, surface surf, int x, int y, int face, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surfCubemapread_v2", (void *)res, s, surf, x, y, face, mode); + +} + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) T surfCubemapread(surface surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + T temp; + + __nv_tex_surf_handler("__surfCubemapread_v2", (typename __nv_surf_trait::cast_type)&temp, (int)sizeof(T), surf, x, y, face, mode); + return temp; + +} + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surfCubemapread(T *res, surface surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + *res = surfCubemapread(surf, x, y, face, mode); + +} + + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surfCubemapLayeredread(T *res, surface surf, int x, int y, int layerFace, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surfCubemapLayeredread_v2", (void *)res, s, surf, x, y, layerFace, mode); + +} + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) T surfCubemapLayeredread(surface surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + T temp; + __nv_tex_surf_handler("__surfCubemapLayeredread_v2", (typename __nv_surf_trait::cast_type)&temp, (int)sizeof(T), surf, x, y, layerFace, mode); + return temp; + +} + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surfCubemapLayeredread(T *res, surface surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + *res = surfCubemapLayeredread(surf, x, y, layerFace, mode); + +} + + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf1Dwrite(T val, surface surf, int x, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surf1Dwrite_v2", (void *)&val, s, surf, x, mode); + +} + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf1Dwrite(T val, surface surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surf1Dwrite_v2", (typename __nv_surf_trait::cast_type)&val, (int)sizeof(T), surf, x, mode); + +} + + + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf2Dwrite(T val, surface surf, int x, int y, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surf2Dwrite_v2", (void *)&val, s, surf, x, y, mode); + +} + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf2Dwrite(T val, surface surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surf2Dwrite_v2", (typename __nv_surf_trait::cast_type)&val, (int)sizeof(T), surf, x, y, mode); + +} + + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf3Dwrite(T val, surface surf, int x, int y, int z, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surf3Dwrite_v2", (void *)&val, s, surf, x, y, z,mode); + +} + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf3Dwrite(T val, surface surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surf3Dwrite_v2", (typename __nv_surf_trait::cast_type)&val, (int)sizeof(T), surf, x, y, z, mode); + +} + + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf1DLayeredwrite(T val, surface surf, int x, int layer, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surf1DLayeredwrite_v2", (void *)&val, s, surf, x, layer,mode); + +} + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf1DLayeredwrite(T val, surface surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surf1DLayeredwrite_v2", (typename __nv_surf_trait::cast_type)&val, (int)sizeof(T), surf, x, layer, mode); + +} + + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf2DLayeredwrite(T val, surface surf, int x, int y, int layer, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surf2DLayeredwrite_v2", (void *)&val, s, surf, x, y, layer,mode); + +} + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf2DLayeredwrite(T val, surface surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surf2DLayeredwrite_v2", (typename __nv_surf_trait::cast_type)&val, (int)sizeof(T), surf, x, y, layer, mode); + +} + + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surfCubemapwrite(T val, surface surf, int x, int y, int face, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surfCubemapwrite_v2", (void *)&val, s, surf, x, y, face, mode); + +} + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surfCubemapwrite(T val, surface surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surfCubemapwrite_v2", (typename __nv_surf_trait::cast_type)&val, (int)sizeof(T), surf, x, y, face, mode); + +} + + + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surfCubemapLayeredwrite(T val, surface surf, int x, int y, int layerFace, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surfCubemapLayeredwrite_v2", (void *)&val, s, surf, x, y, layerFace, mode); + +} + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) void surfCubemapLayeredwrite(T val, surface surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + + __nv_tex_surf_handler("__surfCubemapLayeredwrite_v2", (typename __nv_surf_trait::cast_type)&val, (int)sizeof(T), surf, x, y, layerFace, mode); + +} +# 3291 "/usr/include/crt/device_functions.h" 2 3 4 +# 1 "/usr/include/texture_fetch_functions.h" 1 3 4 +# 66 "/usr/include/texture_fetch_functions.h" 3 4 +template +struct __nv_tex_rmet_ret { }; + +template<> struct __nv_tex_rmet_ret { typedef char type; }; +template<> struct __nv_tex_rmet_ret { typedef signed char type; }; +template<> struct __nv_tex_rmet_ret { typedef unsigned char type; }; +template<> struct __nv_tex_rmet_ret { typedef char1 type; }; +template<> struct __nv_tex_rmet_ret { typedef uchar1 type; }; +template<> struct __nv_tex_rmet_ret { typedef char2 type; }; +template<> struct __nv_tex_rmet_ret { typedef uchar2 type; }; +template<> struct __nv_tex_rmet_ret { typedef char4 type; }; +template<> struct __nv_tex_rmet_ret { typedef uchar4 type; }; + +template<> struct __nv_tex_rmet_ret { typedef short type; }; +template<> struct __nv_tex_rmet_ret { typedef unsigned short type; }; +template<> struct __nv_tex_rmet_ret { typedef short1 type; }; +template<> struct __nv_tex_rmet_ret { typedef ushort1 type; }; +template<> struct __nv_tex_rmet_ret { typedef short2 type; }; +template<> struct __nv_tex_rmet_ret { typedef ushort2 type; }; +template<> struct __nv_tex_rmet_ret { typedef short4 type; }; +template<> struct __nv_tex_rmet_ret { typedef ushort4 type; }; + +template<> struct __nv_tex_rmet_ret { typedef int type; }; +template<> struct __nv_tex_rmet_ret { typedef unsigned int type; }; +template<> struct __nv_tex_rmet_ret { typedef int1 type; }; +template<> struct __nv_tex_rmet_ret { typedef uint1 type; }; +template<> struct __nv_tex_rmet_ret { typedef int2 type; }; +template<> struct __nv_tex_rmet_ret { typedef uint2 type; }; +template<> struct __nv_tex_rmet_ret { typedef int4 type; }; +template<> struct __nv_tex_rmet_ret { typedef uint4 type; }; +# 107 "/usr/include/texture_fetch_functions.h" 3 4 +template<> struct __nv_tex_rmet_ret { typedef float type; }; +template<> struct __nv_tex_rmet_ret { typedef float1 type; }; +template<> struct __nv_tex_rmet_ret { typedef float2 type; }; +template<> struct __nv_tex_rmet_ret { typedef float4 type; }; + + +template struct __nv_tex_rmet_cast { typedef T* type; }; +# 125 "/usr/include/texture_fetch_functions.h" 3 4 +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type tex1Dfetch(texture t, int x) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__tex1Dfetch_v2", (typename __nv_tex_rmet_cast::type)&temp, t, x); + return temp; + +} + +template +struct __nv_tex_rmnf_ret { }; + +template <> struct __nv_tex_rmnf_ret { typedef float type; }; +template <> struct __nv_tex_rmnf_ret { typedef float type; }; +template <> struct __nv_tex_rmnf_ret { typedef float type; }; +template <> struct __nv_tex_rmnf_ret { typedef float type; }; +template <> struct __nv_tex_rmnf_ret { typedef float type; }; +template <> struct __nv_tex_rmnf_ret { typedef float1 type; }; +template <> struct __nv_tex_rmnf_ret { typedef float1 type; }; +template <> struct __nv_tex_rmnf_ret { typedef float1 type; }; +template <> struct __nv_tex_rmnf_ret { typedef float1 type; }; +template <> struct __nv_tex_rmnf_ret { typedef float2 type; }; +template <> struct __nv_tex_rmnf_ret { typedef float2 type; }; +template <> struct __nv_tex_rmnf_ret { typedef float2 type; }; +template <> struct __nv_tex_rmnf_ret { typedef float2 type; }; +template <> struct __nv_tex_rmnf_ret { typedef float4 type; }; +template <> struct __nv_tex_rmnf_ret { typedef float4 type; }; +template <> struct __nv_tex_rmnf_ret { typedef float4 type; }; +template <> struct __nv_tex_rmnf_ret { typedef float4 type; }; + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type tex1Dfetch(texture t, int x) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__tex1Dfetch_rmnf_v2", &type_dummy, &retval, t, x); + return retval; + +} + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type tex1D(texture t, float x) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__tex1D_v2", (typename __nv_tex_rmet_cast::type) &temp, t, x); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type tex1D(texture t, float x) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__tex1D_rmnf_v2", &type_dummy, &retval, t, x); + return retval; + +} + + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type tex2D(texture t, float x, float y) +{ + + typename __nv_tex_rmet_ret::type temp; + + __nv_tex_surf_handler("__tex2D_v2", (typename __nv_tex_rmet_cast::type) &temp, t, x, y); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type tex2D(texture t, float x, float y) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__tex2D_rmnf_v2", &type_dummy, &retval, t, x, y); + return retval; + +} + + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type tex1DLayered(texture t, float x, int layer) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__tex1DLayered_v2", (typename __nv_tex_rmet_cast::type) &temp, t, x, layer); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type tex1DLayered(texture t, float x, int layer) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__tex1DLayered_rmnf_v2", &type_dummy, &retval, t, x, layer); + return retval; + +} + + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type tex2DLayered(texture t, float x, float y, int layer) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__tex2DLayered_v2", (typename __nv_tex_rmet_cast::type) &temp, t, x, y, layer); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type tex2DLayered(texture t, float x, float y, int layer) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__tex2DLayered_rmnf_v2", &type_dummy, &retval, t, x, y, layer); + return retval; + +} + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type tex3D(texture t, float x, float y, float z) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__tex3D_v2", (typename __nv_tex_rmet_cast::type) &temp, t, x, y, z); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type tex3D(texture t, float x, float y, float z) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__tex3D_rmnf_v2", &type_dummy, &retval, t, x, y, z); + return retval; + +} + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type texCubemap(texture t, float x, float y, float z) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__texCubemap_v2", (typename __nv_tex_rmet_cast::type) &temp, t, x, y, z); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type texCubemap(texture t, float x, float y, float z) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__texCubemap_rmnf_v2", &type_dummy, &retval, t, x, y, z); + return retval; + +} + + +template +struct __nv_tex2dgather_ret { }; +template <> struct __nv_tex2dgather_ret { typedef char4 type; }; +template <> struct __nv_tex2dgather_ret { typedef char4 type; }; +template <> struct __nv_tex2dgather_ret { typedef char4 type; }; +template <> struct __nv_tex2dgather_ret { typedef char4 type; }; +template <> struct __nv_tex2dgather_ret { typedef char4 type; }; +template <> struct __nv_tex2dgather_ret { typedef char4 type; }; +template <> struct __nv_tex2dgather_ret { typedef uchar4 type; }; +template <> struct __nv_tex2dgather_ret { typedef uchar4 type; }; +template <> struct __nv_tex2dgather_ret { typedef uchar4 type; }; +template <> struct __nv_tex2dgather_ret { typedef uchar4 type; }; +template <> struct __nv_tex2dgather_ret { typedef uchar4 type; }; + +template <> struct __nv_tex2dgather_ret { typedef short4 type; }; +template <> struct __nv_tex2dgather_ret { typedef short4 type; }; +template <> struct __nv_tex2dgather_ret { typedef short4 type; }; +template <> struct __nv_tex2dgather_ret { typedef short4 type; }; +template <> struct __nv_tex2dgather_ret { typedef short4 type; }; +template <> struct __nv_tex2dgather_ret { typedef ushort4 type; }; +template <> struct __nv_tex2dgather_ret { typedef ushort4 type; }; +template <> struct __nv_tex2dgather_ret { typedef ushort4 type; }; +template <> struct __nv_tex2dgather_ret { typedef ushort4 type; }; +template <> struct __nv_tex2dgather_ret { typedef ushort4 type; }; + +template <> struct __nv_tex2dgather_ret { typedef int4 type; }; +template <> struct __nv_tex2dgather_ret { typedef int4 type; }; +template <> struct __nv_tex2dgather_ret { typedef int4 type; }; +template <> struct __nv_tex2dgather_ret { typedef int4 type; }; +template <> struct __nv_tex2dgather_ret { typedef int4 type; }; +template <> struct __nv_tex2dgather_ret { typedef uint4 type; }; +template <> struct __nv_tex2dgather_ret { typedef uint4 type; }; +template <> struct __nv_tex2dgather_ret { typedef uint4 type; }; +template <> struct __nv_tex2dgather_ret { typedef uint4 type; }; +template <> struct __nv_tex2dgather_ret { typedef uint4 type; }; + +template <> struct __nv_tex2dgather_ret { typedef float4 type; }; +template <> struct __nv_tex2dgather_ret { typedef float4 type; }; +template <> struct __nv_tex2dgather_ret { typedef float4 type; }; +template <> struct __nv_tex2dgather_ret { typedef float4 type; }; +template <> struct __nv_tex2dgather_ret { typedef float4 type; }; + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) typename __nv_tex2dgather_ret::type tex2Dgather(texture t, float x, float y, int comp=0) +{ + + T type_dummy; + typename __nv_tex2dgather_ret::type retval; + __nv_tex_surf_handler("__tex2Dgather_v2", &type_dummy, &retval, t, x, y, comp); + return retval; + +} + + +template struct __nv_tex2dgather_rmnf_ret { }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; +template<> struct __nv_tex2dgather_rmnf_ret { typedef float4 type; }; + +template +static __attribute__((device)) __inline__ __attribute__((always_inline)) typename __nv_tex2dgather_rmnf_ret::type tex2Dgather(texture t, float x, float y, int comp = 0) +{ + + T type_dummy; + typename __nv_tex2dgather_rmnf_ret::type retval; + __nv_tex_surf_handler("__tex2Dgather_rmnf_v2", &type_dummy, &retval, t, x, y, comp); + return retval; + +} + + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type tex1DLod(texture t, float x, float level) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__tex1DLod_v2", (typename __nv_tex_rmet_cast::type)&temp, t, x, level); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type tex1DLod(texture t, float x, float level) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__tex1DLod_rmnf_v2", &type_dummy, &retval, t, x, level); + return retval; + +} + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type tex2DLod(texture t, float x, float y, float level) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__tex2DLod_v2", (typename __nv_tex_rmet_cast::type)&temp, t, x, y, level); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type tex2DLod(texture t, float x, float y, float level) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__tex2DLod_rmnf_v2", &type_dummy, &retval, t, x, y, level); + return retval; + +} + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type tex1DLayeredLod(texture t, float x, int layer, float level) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__tex1DLayeredLod_v2", (typename __nv_tex_rmet_cast::type)&temp, t, x, layer, level); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type tex1DLayeredLod(texture t, float x, int layer, float level) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__tex1DLayeredLod_rmnf_v2", &type_dummy, &retval, t, x, layer, level); + return retval; + +} + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type tex2DLayeredLod(texture t, float x, float y, int layer, float level) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__tex2DLayeredLod_v2", (typename __nv_tex_rmet_cast::type)&temp, t, x, y, layer, level); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type tex2DLayeredLod(texture t, float x, float y, int layer, float level) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__tex2DLayeredLod_rmnf_v2", &type_dummy, &retval, t, x, y, layer, level); + return retval; + +} + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type tex3DLod(texture t, float x, float y, float z, float level) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__tex3DLod_v2",(typename __nv_tex_rmet_cast::type)&temp, t, x, y, z, level); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type tex3DLod(texture t, float x, float y, float z, float level) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__tex3DLod_rmnf_v2", &type_dummy, &retval, t, x, y, z, level); + return retval; + +} + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type texCubemapLod(texture t, float x, float y, float z, float level) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__texCubemapLod_v2",(typename __nv_tex_rmet_cast::type)&temp, t, x, y, z, level); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type texCubemapLod(texture t, float x, float y, float z, float level) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__texCubemapLod_rmnf_v2", &type_dummy, &retval, t, x, y, z, level); + return retval; + +} + + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type texCubemapLayered(texture t, float x, float y, float z, int layer) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__texCubemapLayered_v2",(typename __nv_tex_rmet_cast::type)&temp, t, x, y, z, layer); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type texCubemapLayered(texture t, float x, float y, float z, int layer) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__texCubemapLayered_rmnf_v2", &type_dummy, &retval, t, x, y, z, layer); + return retval; + +} + + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type texCubemapLayeredLod(texture t, float x, float y, float z, int layer, float level) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__texCubemapLayeredLod_v2", (typename __nv_tex_rmet_cast::type)&temp, t, x, y, z, layer, level); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type texCubemapLayeredLod(texture t, float x, float y, float z, int layer, float level) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__texCubemapLayeredLod_rmnf_v2", &type_dummy, &retval, t, x, y, z, layer, level); + return retval; + +} + + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type texCubemapGrad(texture t, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__texCubemapGrad_v2", (typename __nv_tex_rmet_cast::type)&temp, t, x, y, z, &dPdx, &dPdy); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type texCubemapGrad(texture t, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__texCubemapGrad_rmnf_v2", &type_dummy, &retval, t, x, y, z, &dPdx, &dPdy); + return retval; + +} + + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type texCubemapLayeredGrad(texture t, float x, float y, float z, int layer, float4 dPdx, float4 dPdy) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__texCubemapLayeredGrad_v2", (typename __nv_tex_rmet_cast::type)&temp, t, x, y, z, layer, &dPdx, &dPdy); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type texCubemapLayeredGrad(texture t, float x, float y, float z, int layer, float4 dPdx, float4 dPdy) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__texCubemapLayeredGrad_rmnf_v2", &type_dummy, &retval,t, x, y, z, layer, &dPdx, &dPdy); + return retval; + +} + + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type tex1DGrad(texture t, float x, float dPdx, float dPdy) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__tex1DGrad_v2", (typename __nv_tex_rmet_cast::type)&temp, t, x, dPdx, dPdy); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type tex1DGrad(texture t, float x, float dPdx, float dPdy) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__tex1DGrad_rmnf_v2", &type_dummy, &retval,t, x,dPdx, dPdy); + return retval; + +} + + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type tex2DGrad(texture t, float x, float y, float2 dPdx, float2 dPdy) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__tex2DGrad_v2", (typename __nv_tex_rmet_cast::type)&temp, t, x, y, &dPdx, &dPdy); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type tex2DGrad(texture t, float x, float y, float2 dPdx, float2 dPdy) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__tex2DGrad_rmnf_v2", &type_dummy, &retval,t, x, y, &dPdx, &dPdy); + return retval; + +} + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type tex1DLayeredGrad(texture t, float x, int layer, float dPdx, float dPdy) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__tex1DLayeredGrad_v2",(typename __nv_tex_rmet_cast::type)&temp, t, x, layer, dPdx, dPdy); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type tex1DLayeredGrad(texture t, float x, int layer, float dPdx, float dPdy) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__tex1DLayeredGrad_rmnf_v2", &type_dummy, &retval,t, x, layer, dPdx, dPdy); + return retval; + +} + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type tex2DLayeredGrad(texture t, float x, float y, int layer, float2 dPdx, float2 dPdy) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__tex2DLayeredGrad_v2",(typename __nv_tex_rmet_cast::type)&temp, t, x, y, layer, &dPdx, &dPdy); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type tex2DLayeredGrad(texture t, float x, float y, int layer, float2 dPdx, float2 dPdy) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__tex2DLayeredGrad_rmnf_v2", &type_dummy, &retval,t, x, y, layer, &dPdx, &dPdy); + return retval; + +} + + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret::type tex3DGrad(texture t, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + + typename __nv_tex_rmet_ret::type temp; + __nv_tex_surf_handler("__tex3DGrad_v2", (typename __nv_tex_rmet_cast::type)&temp, t, x, y, z, &dPdx, &dPdy); + return temp; + +} + +template +static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret::type tex3DGrad(texture t, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + + T type_dummy; + typename __nv_tex_rmnf_ret::type retval; + __nv_tex_surf_handler("__tex3DGrad_rmnf_v2", &type_dummy, &retval,t, x, y, z, &dPdx, &dPdy); + return retval; + +} +# 3292 "/usr/include/crt/device_functions.h" 2 3 4 +# 1 "/usr/include/texture_indirect_functions.h" 1 3 4 +# 60 "/usr/include/texture_indirect_functions.h" 3 4 +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; }; +# 96 "/usr/include/texture_indirect_functions.h" 3 4 +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 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 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 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 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 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 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 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 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 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 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; + +} +# 3293 "/usr/include/crt/device_functions.h" 2 3 4 +# 1 "/usr/include/surface_indirect_functions.h" 1 3 4 +# 59 "/usr/include/surface_indirect_functions.h" 3 4 +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); + +} +# 3294 "/usr/include/crt/device_functions.h" 2 3 4 + + +extern "C" __attribute__((host)) __attribute__((device)) unsigned __cudaPushCallConfiguration(dim3 gridDim, + dim3 blockDim, + size_t sharedMem = 0, + struct CUstream_st *stream = 0); +# 119 "/usr/include/cuda_runtime.h" 2 3 4 +# 1 "/usr/include/device_launch_parameters.h" 1 3 4 +# 68 "/usr/include/device_launch_parameters.h" 3 4 +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 "/usr/include/cuda_runtime.h" 2 3 4 +# 199 "/usr/include/cuda_runtime.h" 3 4 +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); +} +# 261 "/usr/include/cuda_runtime.h" 3 4 +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); +} +# 305 "/usr/include/cuda_runtime.h" 3 4 +static __inline__ __attribute__((host)) cudaError_t cudaEventCreate( + cudaEvent_t *event, + unsigned int flags +) +{ + return ::cudaEventCreateWithFlags(event, flags); +} +# 370 "/usr/include/cuda_runtime.h" 3 4 +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); +} +# 499 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocManaged( + T **devPtr, + size_t size, + unsigned int flags = 0x01 +) +{ + return ::cudaMallocManaged((void**)(void*)devPtr, size, flags); +} +# 589 "/usr/include/cuda_runtime.h" 3 4 +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); +} +# 667 "/usr/include/cuda_runtime.h" 3 4 +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); +} +# 721 "/usr/include/cuda_runtime.h" 3 4 +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); +} +# 769 "/usr/include/cuda_runtime.h" 3 4 +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); +} +# 823 "/usr/include/cuda_runtime.h" 3 4 +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); +} +# 859 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) cudaError_t cudaGetSymbolAddress( + void **devPtr, + const T &symbol +) +{ + return ::cudaGetSymbolAddress(devPtr, (const void*)&symbol); +} +# 891 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) cudaError_t cudaGetSymbolSize( + size_t *size, + const T &symbol +) +{ + return ::cudaGetSymbolSize(size, (const void*)&symbol); +} +# 935 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) cudaError_t cudaBindTexture( + size_t *offset, + const struct texture &tex, + const void *devPtr, + const struct cudaChannelFormatDesc &desc, + size_t size = (0x7fffffff * 2U + 1U) +) +{ + return ::cudaBindTexture(offset, &tex, devPtr, &desc, size); +} +# 981 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) cudaError_t cudaBindTexture( + size_t *offset, + const struct texture &tex, + const void *devPtr, + size_t size = (0x7fffffff * 2U + 1U) +) +{ + return cudaBindTexture(offset, tex, devPtr, tex.channelDesc, size); +} +# 1038 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) cudaError_t cudaBindTexture2D( + size_t *offset, + const struct texture &tex, + const void *devPtr, + const struct cudaChannelFormatDesc &desc, + size_t width, + size_t height, + size_t pitch +) +{ + return ::cudaBindTexture2D(offset, &tex, devPtr, &desc, width, height, pitch); +} +# 1097 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) cudaError_t cudaBindTexture2D( + size_t *offset, + const struct texture &tex, + const void *devPtr, + size_t width, + size_t height, + size_t pitch +) +{ + return ::cudaBindTexture2D(offset, &tex, devPtr, &tex.channelDesc, width, height, pitch); +} +# 1140 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) cudaError_t cudaBindTextureToArray( + const struct texture &tex, + cudaArray_const_t array, + const struct cudaChannelFormatDesc &desc +) +{ + return ::cudaBindTextureToArray(&tex, array, &desc); +} +# 1179 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) cudaError_t cudaBindTextureToArray( + const struct texture &tex, + cudaArray_const_t array +) +{ + struct cudaChannelFormatDesc desc; + cudaError_t err = ::cudaGetChannelDesc(&desc, array); + + return err == cudaSuccess ? cudaBindTextureToArray(tex, array, desc) : err; +} +# 1221 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) cudaError_t cudaBindTextureToMipmappedArray( + const struct texture &tex, + cudaMipmappedArray_const_t mipmappedArray, + const struct cudaChannelFormatDesc &desc +) +{ + return ::cudaBindTextureToMipmappedArray(&tex, mipmappedArray, &desc); +} +# 1260 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) cudaError_t cudaBindTextureToMipmappedArray( + const struct texture &tex, + cudaMipmappedArray_const_t mipmappedArray +) +{ + struct cudaChannelFormatDesc desc; + cudaArray_t levelArray; + cudaError_t err = ::cudaGetMipmappedArrayLevel(&levelArray, mipmappedArray, 0); + + if (err != cudaSuccess) { + return err; + } + err = ::cudaGetChannelDesc(&desc, levelArray); + + return err == cudaSuccess ? cudaBindTextureToMipmappedArray(tex, mipmappedArray, desc) : err; +} +# 1303 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) cudaError_t cudaUnbindTexture( + const struct texture &tex +) +{ + return ::cudaUnbindTexture(&tex); +} +# 1339 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) cudaError_t cudaGetTextureAlignmentOffset( + size_t *offset, + const struct texture &tex +) +{ + return ::cudaGetTextureAlignmentOffset(offset, &tex); +} +# 1391 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncSetCacheConfig( + T *func, + enum cudaFuncCache cacheConfig +) +{ + return ::cudaFuncSetCacheConfig((const void*)func, cacheConfig); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncSetSharedMemConfig( + T *func, + enum cudaSharedMemConfig config +) +{ + return ::cudaFuncSetSharedMemConfig((const void*)func, config); +} +# 1436 "/usr/include/cuda_runtime.h" 3 4 +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); +} +# 1487 "/usr/include/cuda_runtime.h" 3 4 +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)) __cudaOccupancyB2DHelper(size_t n_) : n(n_) {} + inline __attribute__((host)) size_t operator()(int) + { + return n; + } +}; +# 1556 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) 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; +} +# 1751 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxPotentialBlockSizeVariableSMem( + int *minGridSize, + int *blockSize, + T func, + UnaryFunction blockSizeToDynamicSMemSize, + int blockSizeLimit = 0) +{ + return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, blockSizeToDynamicSMemSize, blockSizeLimit, 0x00); +} +# 1796 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) 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); +} +# 1855 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) 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); +} +# 1896 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncGetAttributes( + struct cudaFuncAttributes *attr, + T *entry +) +{ + return ::cudaFuncGetAttributes(attr, (const void*)entry); +} +# 1941 "/usr/include/cuda_runtime.h" 3 4 +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncSetAttribute( + T *entry, + enum cudaFuncAttribute attr, + int value +) +{ + return ::cudaFuncSetAttribute((const void*)entry, attr, value); +} +# 1973 "/usr/include/cuda_runtime.h" 3 4 +template +static __attribute__((deprecated)) __inline__ __attribute__((host)) cudaError_t cudaBindSurfaceToArray( + const struct surface &surf, + cudaArray_const_t array, + const struct cudaChannelFormatDesc &desc +) +{ + return ::cudaBindSurfaceToArray(&surf, array, &desc); +} +# 2004 "/usr/include/cuda_runtime.h" 3 4 +template +static __attribute__((deprecated)) __inline__ __attribute__((host)) cudaError_t cudaBindSurfaceToArray( + const struct surface &surf, + cudaArray_const_t array +) +{ + struct cudaChannelFormatDesc desc; + cudaError_t err = ::cudaGetChannelDesc(&desc, array); + + return err == cudaSuccess ? cudaBindSurfaceToArray(surf, array, desc) : err; +} +# 2025 "/usr/include/cuda_runtime.h" 3 4 +#pragma GCC diagnostic pop +# 1 "" 2 +# 1 "CMakeCUDACompilerId.cu" +# 40 "CMakeCUDACompilerId.cu" + +# 40 "CMakeCUDACompilerId.cu" +char const* info_compiler = "INFO" ":" "compiler[" "NVIDIA" "]"; +# 278 "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' + (((10) / 10000000)%10)), ('0' + (((10) / 1000000)%10)), ('0' + (((10) / 100000)%10)), ('0' + (((10) / 10000)%10)), ('0' + (((10) / 1000)%10)), ('0' + (((10) / 100)%10)), ('0' + (((10) / 10)%10)), ('0' + ((10) % 10)), + + '.', ('0' + (((1) / 10000000)%10)), ('0' + (((1) / 1000000)%10)), ('0' + (((1) / 100000)%10)), ('0' + (((1) / 10000)%10)), ('0' + (((1) / 1000)%10)), ('0' + (((1) / 100)%10)), ('0' + (((1) / 10)%10)), ('0' + ((1) % 10)), + + '.', ('0' + (((243) / 10000000)%10)), ('0' + (((243) / 1000000)%10)), ('0' + (((243) / 100000)%10)), ('0' + (((243) / 10000)%10)), ('0' + (((243) / 1000)%10)), ('0' + (((243) / 100)%10)), ('0' + (((243) / 10)%10)), ('0' + ((243) % 10)), + + + + + + ']','\0'}; +# 325 "CMakeCUDACompilerId.cu" +char const* info_platform = "INFO" ":" "platform[" "Linux" "]"; +char const* info_arch = "INFO" ":" "arch[" "]"; + + + + +const char* info_language_dialect_default = "INFO" ":" "dialect_default[" + + + + + + "14" + + + + + +"]"; + + + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; + + require += info_version[argc]; + + + + + + + + require += info_language_dialect_default[argc]; + (void)argv; + return require; +} diff --git a/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.c b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.c new file mode 100644 index 0000000..4cc2bff --- /dev/null +++ b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.c @@ -0,0 +1,25 @@ +# 1 "CMakeCUDACompilerId.cu" +# 40 "CMakeCUDACompilerId.cu" +extern const char *info_compiler; +# 278 "CMakeCUDACompilerId.cu" +static const char info_version[50]; +# 325 "CMakeCUDACompilerId.cu" +extern const char *info_platform; +extern const char *info_arch; + + + + +extern const char *info_language_dialect_default; +# 40 "CMakeCUDACompilerId.cu" +const char *info_compiler = ((const char *)"INFO:compiler[NVIDIA]"); +# 278 "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)48),((char)46),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)48),((char)49),((char)46),((char)48),((char)48),((char)48),((char)48),((char)48),((char)50),((char)52),((char)51),((char)93),((char)0)}; +# 325 "CMakeCUDACompilerId.cu" +const char *info_platform = ((const char *)"INFO:platform[Linux]"); +const char *info_arch = ((const char *)"INFO:arch[]"); + + + + +const char *info_language_dialect_default = ((const char *)"INFO:dialect_default[14]"); diff --git a/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.gpu b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.gpu new file mode 100644 index 0000000..983c34d --- /dev/null +++ b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.gpu @@ -0,0 +1,7 @@ +typedef char __nv_bool; +# 216 "/usr/lib/gcc/x86_64-linux-gnu/8/include/stddef.h" 3 +typedef unsigned long size_t; +#include "crt/device_runtime.h" +# 238 "/usr/include/x86_64-linux-gnu/c++/8/bits/c++config.h" 3 +typedef unsigned long _ZSt6size_t; +#include "common_functions.h" diff --git a/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.stub.c b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cudafe1.stub.c new file mode 100644 index 0000000..2ebe7e6 --- /dev/null +++ b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.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/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.module_id b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.module_id new file mode 100644 index 0000000..ec5bcbf --- /dev/null +++ b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.module_id @@ -0,0 +1 @@ +_27_CMakeCUDACompilerId_cpp1_ii_bd57c623 \ No newline at end of file diff --git a/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.ptx b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.ptx new file mode 100644 index 0000000..1bb09dc --- /dev/null +++ b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCUDA/tmp/CMakeCUDACompilerId.ptx @@ -0,0 +1,14 @@ +// +// Generated by NVIDIA NVVM Compiler +// +// Compiler Build ID: CL-26907403 +// Cuda compilation tools, release 10.1, V10.1.243 +// Based on LLVM 3.4svn +// + +.version 6.4 +.target sm_30 +.address_size 64 + + + diff --git a/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCXX/CMakeCXXCompilerId.cpp b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCXX/CMakeCXXCompilerId.cpp new file mode 100644 index 0000000..69cfdba --- /dev/null +++ b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCXX/CMakeCXXCompilerId.cpp @@ -0,0 +1,660 @@ +/* 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 + + +/* Version number components: V=Version, R=Revision, P=Patch + Version date components: YYYY=Year, MM=Month, DD=Day */ + +#if defined(__COMO__) +# define COMPILER_ID "Comeau" + /* __COMO_VERSION__ = VRR */ +# define COMPILER_VERSION_MAJOR DEC(__COMO_VERSION__ / 100) +# define COMPILER_VERSION_MINOR DEC(__COMO_VERSION__ % 100) + +#elif 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 */ +# 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 +# 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(__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(__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(__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(_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(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version) +# define COMPILER_ID "Fujitsu" + +#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(__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 % 10000) +# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_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(__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(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__) +# define COMPILER_ID "ADSP" +#if defined(__VISUALDSPVERSION__) + /* __VISUALDSPVERSION__ = 0xVVRRPP00 */ +# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24) +# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8 & 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__)) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 100) +# define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100)) +# define COMPILER_VERSION_PATCH DEC(__SUBVERSION__) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# endif + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#ifdef __QNXNTO__ +char const* qnxnto = "INFO" ":" "qnxnto[]"; +#endif + +#if defined(__CRAYXE) || defined(__CRAYXC) +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(__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" + +# 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 + +#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_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" + +# 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 +#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 components. */ +#ifdef 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'}; +#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 "]"; + + + + +#if defined(__INTEL_COMPILER) && defined(_MSVC_LANG) && _MSVC_LANG < 201403L +# if defined(__INTEL_CXX11_MODE__) +# if defined(__cpp_aggregate_nsdmi) +# define CXX_STD 201402L +# else +# define CXX_STD 201103L +# endif +# else +# define CXX_STD 199711L +# endif +#elif defined(_MSC_VER) && defined(_MSVC_LANG) +# define CXX_STD _MSVC_LANG +#else +# define CXX_STD __cplusplus +#endif + +const char* info_language_dialect_default = "INFO" ":" "dialect_default[" +#if CXX_STD > 201703L + "20" +#elif CXX_STD >= 201703L + "17" +#elif CXX_STD >= 201402L + "14" +#elif CXX_STD >= 201103L + "11" +#else + "98" +#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 COMPILER_VERSION_INTERNAL + 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(__CRAYXE) || defined(__CRAYXC) + require += info_cray[argc]; +#endif + require += info_language_dialect_default[argc]; + (void)argv; + return require; +} diff --git a/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCXX/a.out b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCXX/a.out new file mode 100755 index 0000000..34ec4a0 Binary files /dev/null and b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCXX/a.out differ diff --git a/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/CMakeError.log b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/CMakeError.log new file mode 100644 index 0000000..0ebed5d --- /dev/null +++ b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/CMakeError.log @@ -0,0 +1,64 @@ +Compiling the CUDA compiler identification source file "CMakeCUDACompilerId.cu" failed. +Compiler: /usr/bin/nvcc +Build flags: +Id flags: -v;--keep;--keep-dir;tmp + +The output was: +255 +#$ _SPACE_= +#$ _CUDART_=cudart +#$ _HERE_=/usr/lib/nvidia-cuda-toolkit/bin +#$ _THERE_=/usr/lib/nvidia-cuda-toolkit/bin +#$ _TARGET_SIZE_= +#$ _TARGET_DIR_= +#$ _TARGET_SIZE_=64 +#$ NVVMIR_LIBRARY_DIR=/usr/lib/nvidia-cuda-toolkit/libdevice +#$ PATH=/usr/lib/nvidia-cuda-toolkit/bin:/usr/local/cuda-11.7/bin:/home/higepi/.local/bin:/usr/local/cuda-11.7/bin:/home/higepi/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin +#$ LIBRARIES= -L/usr/lib/x86_64-linux-gnu/stubs -L/usr/lib/x86_64-linux-gnu +#$ rm tmp/a_dlink.reg.c +#$ gcc -D__CUDA_ARCH__=300 -E -x c++ -DCUDA_DOUBLE_MATH_FUNCTIONS -D__CUDACC__ -D__NVCC__ -D__CUDACC_VER_MAJOR__=10 -D__CUDACC_VER_MINOR__=1 -D__CUDACC_VER_BUILD__=243 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" > "tmp/CMakeCUDACompilerId.cpp1.ii" +#$ cicc --c++14 --gnu_version=90400 --allow_managed -arch compute_30 -m64 -ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 --include_file_name "CMakeCUDACompilerId.fatbin.c" -tused -nvvmir-library "/usr/lib/nvidia-cuda-toolkit/libdevice/libdevice.10.bc" --gen_module_id_file --module_id_file_name "tmp/CMakeCUDACompilerId.module_id" --orig_src_file_name "CMakeCUDACompilerId.cu" --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_30 -m64 "tmp/CMakeCUDACompilerId.ptx" -o "tmp/CMakeCUDACompilerId.sm_30.cubin" +ptxas fatal : Value 'sm_30' is not defined for option 'gpu-name' +# --error 0xff -- + + +Compiling the CUDA compiler identification source file "CMakeCUDACompilerId.cu" failed. +Compiler: /usr/bin/nvcc +Build flags: +Id flags: -v;--keep;--keep-dir;tmp + +The output was: +255 +#$ _SPACE_= +#$ _CUDART_=cudart +#$ _HERE_=/usr/lib/nvidia-cuda-toolkit/bin +#$ _THERE_=/usr/lib/nvidia-cuda-toolkit/bin +#$ _TARGET_SIZE_= +#$ _TARGET_DIR_= +#$ _TARGET_SIZE_=64 +#$ NVVMIR_LIBRARY_DIR=/usr/lib/nvidia-cuda-toolkit/libdevice +#$ PATH=/usr/lib/nvidia-cuda-toolkit/bin:/usr/local/cuda-11.7/bin:/home/higepi/.local/bin:/usr/local/cuda-11.7/bin:/home/higepi/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin +#$ LIBRARIES= -L/usr/lib/x86_64-linux-gnu/stubs -L/usr/lib/x86_64-linux-gnu +#$ rm tmp/a_dlink.reg.c +#$ gcc -D__CUDA_ARCH__=300 -E -x c++ -DCUDA_DOUBLE_MATH_FUNCTIONS -D__CUDACC__ -D__NVCC__ -D__CUDACC_VER_MAJOR__=10 -D__CUDACC_VER_MINOR__=1 -D__CUDACC_VER_BUILD__=243 -include "cuda_runtime.h" -m64 "CMakeCUDACompilerId.cu" > "tmp/CMakeCUDACompilerId.cpp1.ii" +#$ cicc --c++14 --gnu_version=90400 --allow_managed -arch compute_30 -m64 -ftz=0 -prec_div=1 -prec_sqrt=1 -fmad=1 --include_file_name "CMakeCUDACompilerId.fatbin.c" -tused -nvvmir-library "/usr/lib/nvidia-cuda-toolkit/libdevice/libdevice.10.bc" --gen_module_id_file --module_id_file_name "tmp/CMakeCUDACompilerId.module_id" --orig_src_file_name "CMakeCUDACompilerId.cu" --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_30 -m64 "tmp/CMakeCUDACompilerId.ptx" -o "tmp/CMakeCUDACompilerId.sm_30.cubin" +ptxas fatal : Value 'sm_30' is not defined for option 'gpu-name' +# --error 0xff -- + + +Determining if the CUDA compiler works failed with the following output: +Change Dir: /home/higepi/Documents/M2R_SETI/M2_SETI/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/CMakeTmp + +Run Build Command(s):/usr/bin/make cmTC_0693a/fast && /usr/bin/make -f CMakeFiles/cmTC_0693a.dir/build.make CMakeFiles/cmTC_0693a.dir/build +make[1]: Entering directory '/home/higepi/Documents/M2R_SETI/M2_SETI/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/CMakeTmp' +Building CUDA object CMakeFiles/cmTC_0693a.dir/main.cu.o +/usr/bin/nvcc -x cu -c /home/higepi/Documents/M2R_SETI/M2_SETI/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/CMakeTmp/main.cu -o CMakeFiles/cmTC_0693a.dir/main.cu.o +ptxas fatal : Value 'sm_30' is not defined for option 'gpu-name' +make[1]: *** [CMakeFiles/cmTC_0693a.dir/build.make:66: CMakeFiles/cmTC_0693a.dir/main.cu.o] Error 255 +make[1]: Leaving directory '/home/higepi/Documents/M2R_SETI/M2_SETI/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/CMakeTmp' +make: *** [Makefile:121: cmTC_0693a/fast] Error 2 + + + diff --git a/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/CMakeOutput.log b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/CMakeOutput.log new file mode 100644 index 0000000..0decb16 --- /dev/null +++ b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/CMakeOutput.log @@ -0,0 +1,237 @@ +The system is: Linux - 5.4.0-132-generic - x86_64 +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/higepi/Documents/M2R_SETI/M2_SETI/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/3.16.3/CompilerIdCXX/a.out" + +Determining if the CXX compiler works passed with the following output: +Change Dir: /home/higepi/Documents/M2R_SETI/M2_SETI/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/CMakeTmp + +Run Build Command(s):/usr/bin/make cmTC_ea19b/fast && /usr/bin/make -f CMakeFiles/cmTC_ea19b.dir/build.make CMakeFiles/cmTC_ea19b.dir/build +make[1]: Entering directory '/home/higepi/Documents/M2R_SETI/M2_SETI/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/CMakeTmp' +Building CXX object CMakeFiles/cmTC_ea19b.dir/testCXXCompiler.cxx.o +/usr/bin/c++ -o CMakeFiles/cmTC_ea19b.dir/testCXXCompiler.cxx.o -c /home/higepi/Documents/M2R_SETI/M2_SETI/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/CMakeTmp/testCXXCompiler.cxx +Linking CXX executable cmTC_ea19b +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_ea19b.dir/link.txt --verbose=1 +/usr/bin/c++ -rdynamic CMakeFiles/cmTC_ea19b.dir/testCXXCompiler.cxx.o -o cmTC_ea19b +make[1]: Leaving directory '/home/higepi/Documents/M2R_SETI/M2_SETI/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/CMakeTmp' + + + +Detecting CXX compiler ABI info compiled with the following output: +Change Dir: /home/higepi/Documents/M2R_SETI/M2_SETI/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/CMakeTmp + +Run Build Command(s):/usr/bin/make cmTC_97989/fast && /usr/bin/make -f CMakeFiles/cmTC_97989.dir/build.make CMakeFiles/cmTC_97989.dir/build +make[1]: Entering directory '/home/higepi/Documents/M2R_SETI/M2_SETI/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/CMakeTmp' +Building CXX object CMakeFiles/cmTC_97989.dir/CMakeCXXCompilerABI.cpp.o +/usr/bin/c++ -v -o CMakeFiles/cmTC_97989.dir/CMakeCXXCompilerABI.cpp.o -c /usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp +Using built-in specs. +COLLECT_GCC=/usr/bin/c++ +OFFLOAD_TARGET_NAMES=nvptx-none:hsa +OFFLOAD_TARGET_DEFAULT=1 +Target: x86_64-linux-gnu +Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.1' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --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-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 --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --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-9-Av3uEd/gcc-9-9.4.0/debian/tmp-nvptx/usr,hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu +Thread model: posix +gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.1) +COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_97989.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' + /usr/lib/gcc/x86_64-linux-gnu/9/cc1plus -quiet -v -imultiarch x86_64-linux-gnu -D_GNU_SOURCE /usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpbase CMakeCXXCompilerABI.cpp -mtune=generic -march=x86-64 -auxbase-strip CMakeFiles/cmTC_97989.dir/CMakeCXXCompilerABI.cpp.o -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccyzxXTR.s +GNU C++14 (Ubuntu 9.4.0-1ubuntu1~20.04.1) version 9.4.0 (x86_64-linux-gnu) + compiled by GNU C version 9.4.0, GMP version 6.2.0, MPFR version 4.0.2, MPC version 1.1.0, isl version isl-0.22.1-GMP + +GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072 +ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/9" +ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu" +ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/include-fixed" +ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/../../../../x86_64-linux-gnu/include" +#include "..." search starts here: +#include <...> search starts here: + /usr/include/c++/9 + /usr/include/x86_64-linux-gnu/c++/9 + /usr/include/c++/9/backward + /usr/lib/gcc/x86_64-linux-gnu/9/include + /usr/local/include + /usr/include/x86_64-linux-gnu + /usr/include +End of search list. +GNU C++14 (Ubuntu 9.4.0-1ubuntu1~20.04.1) version 9.4.0 (x86_64-linux-gnu) + compiled by GNU C version 9.4.0, GMP version 6.2.0, MPFR version 4.0.2, MPC version 1.1.0, isl version isl-0.22.1-GMP + +GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072 +Compiler executable checksum: 65fe925b83d3956b533de4aaba7dace0 +COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_97989.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' + as -v --64 -o CMakeFiles/cmTC_97989.dir/CMakeCXXCompilerABI.cpp.o /tmp/ccyzxXTR.s +GNU assembler version 2.34 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.34 +COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/ +LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/ +COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_97989.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' +Linking CXX executable cmTC_97989 +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_97989.dir/link.txt --verbose=1 +/usr/bin/c++ -v -rdynamic CMakeFiles/cmTC_97989.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_97989 +Using built-in specs. +COLLECT_GCC=/usr/bin/c++ +COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper +OFFLOAD_TARGET_NAMES=nvptx-none:hsa +OFFLOAD_TARGET_DEFAULT=1 +Target: x86_64-linux-gnu +Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.1' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --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-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 --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --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-9-Av3uEd/gcc-9-9.4.0/debian/tmp-nvptx/usr,hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu +Thread model: posix +gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.1) +COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/ +LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/ +COLLECT_GCC_OPTIONS='-v' '-rdynamic' '-o' 'cmTC_97989' '-shared-libgcc' '-mtune=generic' '-march=x86-64' + /usr/lib/gcc/x86_64-linux-gnu/9/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/9/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper -plugin-opt=-fresolution=/tmp/ccrpPBtk.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 -export-dynamic -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_97989 /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/9/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/9 -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/9/../../.. CMakeFiles/cmTC_97989.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/9/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crtn.o +COLLECT_GCC_OPTIONS='-v' '-rdynamic' '-o' 'cmTC_97989' '-shared-libgcc' '-mtune=generic' '-march=x86-64' +make[1]: Leaving directory '/home/higepi/Documents/M2R_SETI/M2_SETI/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/CMakeTmp' + + + +Parsed CXX implicit include dir info from above output: rv=done + found start of include info + found start of implicit include info + add: [/usr/include/c++/9] + add: [/usr/include/x86_64-linux-gnu/c++/9] + add: [/usr/include/c++/9/backward] + add: [/usr/lib/gcc/x86_64-linux-gnu/9/include] + add: [/usr/local/include] + add: [/usr/include/x86_64-linux-gnu] + add: [/usr/include] + end of search list found + collapse include dir [/usr/include/c++/9] ==> [/usr/include/c++/9] + collapse include dir [/usr/include/x86_64-linux-gnu/c++/9] ==> [/usr/include/x86_64-linux-gnu/c++/9] + collapse include dir [/usr/include/c++/9/backward] ==> [/usr/include/c++/9/backward] + collapse include dir [/usr/lib/gcc/x86_64-linux-gnu/9/include] ==> [/usr/lib/gcc/x86_64-linux-gnu/9/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: [/usr/include/c++/9;/usr/include/x86_64-linux-gnu/c++/9;/usr/include/c++/9/backward;/usr/lib/gcc/x86_64-linux-gnu/9/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include] + + +Parsed CXX implicit link information from above output: + link line regex: [^( *|.*[/\])(ld|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\]+-)?ld|collect2)[^/\]*( |$)] + ignore line: [Change Dir: /home/higepi/Documents/M2R_SETI/M2_SETI/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/CMakeTmp] + ignore line: [] + ignore line: [Run Build Command(s):/usr/bin/make cmTC_97989/fast && /usr/bin/make -f CMakeFiles/cmTC_97989.dir/build.make CMakeFiles/cmTC_97989.dir/build] + ignore line: [make[1]: Entering directory '/home/higepi/Documents/M2R_SETI/M2_SETI/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/CMakeTmp'] + ignore line: [Building CXX object CMakeFiles/cmTC_97989.dir/CMakeCXXCompilerABI.cpp.o] + ignore line: [/usr/bin/c++ -v -o CMakeFiles/cmTC_97989.dir/CMakeCXXCompilerABI.cpp.o -c /usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/c++] + ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:hsa] + ignore line: [OFFLOAD_TARGET_DEFAULT=1] + ignore line: [Target: x86_64-linux-gnu] + ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.1' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --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-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 --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --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-9-Av3uEd/gcc-9-9.4.0/debian/tmp-nvptx/usr hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu] + ignore line: [Thread model: posix] + ignore line: [gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.1) ] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_97989.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64'] + ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/9/cc1plus -quiet -v -imultiarch x86_64-linux-gnu -D_GNU_SOURCE /usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpbase CMakeCXXCompilerABI.cpp -mtune=generic -march=x86-64 -auxbase-strip CMakeFiles/cmTC_97989.dir/CMakeCXXCompilerABI.cpp.o -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccyzxXTR.s] + ignore line: [GNU C++14 (Ubuntu 9.4.0-1ubuntu1~20.04.1) version 9.4.0 (x86_64-linux-gnu)] + ignore line: [ compiled by GNU C version 9.4.0 GMP version 6.2.0 MPFR version 4.0.2 MPC version 1.1.0 isl version isl-0.22.1-GMP] + ignore line: [] + 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++/9"] + ignore line: [ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/include-fixed"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/../../../../x86_64-linux-gnu/include"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /usr/include/c++/9] + ignore line: [ /usr/include/x86_64-linux-gnu/c++/9] + ignore line: [ /usr/include/c++/9/backward] + ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/9/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++14 (Ubuntu 9.4.0-1ubuntu1~20.04.1) version 9.4.0 (x86_64-linux-gnu)] + ignore line: [ compiled by GNU C version 9.4.0 GMP version 6.2.0 MPFR version 4.0.2 MPC version 1.1.0 isl version isl-0.22.1-GMP] + ignore line: [] + ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072] + ignore line: [Compiler executable checksum: 65fe925b83d3956b533de4aaba7dace0] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_97989.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64'] + ignore line: [ as -v --64 -o CMakeFiles/cmTC_97989.dir/CMakeCXXCompilerABI.cpp.o /tmp/ccyzxXTR.s] + ignore line: [GNU assembler version 2.34 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.34] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_97989.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64'] + ignore line: [Linking CXX executable cmTC_97989] + ignore line: [/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_97989.dir/link.txt --verbose=1] + ignore line: [/usr/bin/c++ -v -rdynamic CMakeFiles/cmTC_97989.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_97989 ] + 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/9/lto-wrapper] + ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:hsa] + ignore line: [OFFLOAD_TARGET_DEFAULT=1] + ignore line: [Target: x86_64-linux-gnu] + ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.1' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --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-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 --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --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-9-Av3uEd/gcc-9-9.4.0/debian/tmp-nvptx/usr hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu] + ignore line: [Thread model: posix] + ignore line: [gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.1) ] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-rdynamic' '-o' 'cmTC_97989' '-shared-libgcc' '-mtune=generic' '-march=x86-64'] + link line: [ /usr/lib/gcc/x86_64-linux-gnu/9/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/9/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper -plugin-opt=-fresolution=/tmp/ccrpPBtk.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 -export-dynamic -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_97989 /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/9/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/9 -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/9/../../.. CMakeFiles/cmTC_97989.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/9/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crtn.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/9/collect2] ==> ignore + arg [-plugin] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/9/liblto_plugin.so] ==> ignore + arg [-plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper] ==> ignore + arg [-plugin-opt=-fresolution=/tmp/ccrpPBtk.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 [-export-dynamic] ==> 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_97989] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/Scrt1.o] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crti.o] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/9/crtbeginS.o] ==> ignore + arg [-L/usr/lib/gcc/x86_64-linux-gnu/9] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../../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/usr/lib/gcc/x86_64-linux-gnu/9/../../..] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../..] + arg [CMakeFiles/cmTC_97989.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/9/crtendS.o] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crtn.o] ==> ignore + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/9] ==> [/usr/lib/gcc/x86_64-linux-gnu/9] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../../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 [/usr/lib/gcc/x86_64-linux-gnu/9/../../..] ==> [/usr/lib] + implicit libs: [stdc++;m;gcc_s;gcc;c;gcc_s;gcc] + implicit dirs: [/usr/lib/gcc/x86_64-linux-gnu/9;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib] + implicit fwks: [] + + diff --git a/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/cmake.check_cache b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/cmake.check_cache new file mode 100644 index 0000000..3dccd73 --- /dev/null +++ b/A4/TP_GPU-master/TP1_image/CUDA/build/CMakeFiles/cmake.check_cache @@ -0,0 +1 @@ +# This file is generated by cmake for dependency checking of the CMakeCache.txt file diff --git a/D3/TP/TP_SETI_SVM/GridSearchCV.jpg b/D3/TP/TP_SETI_SVM/GridSearchCV.jpg new file mode 100644 index 0000000..d898dc9 Binary files /dev/null and b/D3/TP/TP_SETI_SVM/GridSearchCV.jpg differ diff --git a/D3/TP/TP_SETI_SVM/SETI_2022-2023_TP_SVM.pdf b/D3/TP/TP_SETI_SVM/SETI_2022-2023_TP_SVM.pdf new file mode 100644 index 0000000..1a15df7 Binary files /dev/null and b/D3/TP/TP_SETI_SVM/SETI_2022-2023_TP_SVM.pdf differ diff --git a/D3/TP/TP_SETI_SVM/SVM.ipynb b/D3/TP/TP_SETI_SVM/SVM.ipynb new file mode 100644 index 0000000..3b55b5b --- /dev/null +++ b/D3/TP/TP_SETI_SVM/SVM.ipynb @@ -0,0 +1,280 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# TP 3 SVM\n", + "On se propose de faire de la modélisation par SVM sur des problématiques de discrimination, en utilisant la bibliothèque scikit-learn.\n", + "\n", + "On veut : \n", + "- Traiter un problème de discrimination linéairement séparable\n", + "- Traiter un problème non linéairement séparable (SVM à noyaux)\n", + "- Traiter le problème de la discrimination de chiffres manuscrits" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Problème linéairement séparable" + ] + }, + { + "cell_type": "code", + "execution_count": 1042, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from sklearn.svm import SVC" + ] + }, + { + "cell_type": "code", + "execution_count": 1043, + "metadata": {}, + "outputs": [], + "source": [ + "def genere_ex_1(n1=100, n2=50, mu1=[0,3], mu2=[3,0], sd1=0.15, sd2=0.2):\n", + " X = np.concatenate((np.random.multivariate_normal(mu1, np.diagflat(sd1*np.ones(2)), n1),\n", + " np.random.multivariate_normal(mu2, np.diagflat(sd2*np.ones(2)),n2)))\n", + "\n", + " Y = np.concatenate((np.ones((n1,1)), -1*np.ones((n2,1))))[:,0]\n", + " return X,Y" + ] + }, + { + "cell_type": "code", + "execution_count": 1044, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_data_hyperplan(X, Y, classifier, name):\n", + " w = classifier.coef_[0]\n", + " b = classifier.intercept_[0]\n", + " a = -w[0] / w[1]\n", + " xx = np.linspace(min(X[:,0]), max(X[:,0]))\n", + " yy = a * xx - b/w[1]\n", + "\n", + " # print(X.size)\n", + "\n", + " # b1 = [(X[i,0]-a*X[i,0]- b/w[1]) for i in range(0,int(X.size/2))]\n", + " # b1 = min(b1)\n", + "\n", + " # b2 = [(X[i,1]-a*X[i,1]/w[1]) for i in range(0,int(X.size/2))]\n", + " # b2 = max(b2)\n", + "\n", + " color = ['red' if c >= 0 else 'blue' for c in Y]\n", + " plt.scatter(X[:,0], X[:,1], color=color)\n", + "\n", + " plt.plot(xx,yy, color='black')\n", + " plt.plot(xx, yy+1, color='green')\n", + " plt.plot(xx, yy-1, color='green')\n", + " plt.xlabel(\"x1\")\n", + " plt.ylabel(\"x2\")\n", + " plt.title(\"Classe 1 (red), Classe -1 (blue)\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 1045, + "metadata": {}, + "outputs": [], + "source": [ + "def main(X,Y):\n", + " classifier = SVC(kernel='linear', probability=True)\n", + " classifier = classifier.fit(X, Y)\n", + "\n", + " plot_data_hyperplan(X, Y, classifier, 'Graph_SVM_linear')" + ] + }, + { + "cell_type": "code", + "execution_count": 1046, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "X, Y = genere_ex_1() \n", + "main(X, Y)\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Problème non linéairement séparable\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1047, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import GridSearchCV" + ] + }, + { + "cell_type": "code", + "execution_count": 1048, + "metadata": {}, + "outputs": [], + "source": [ + "def genere_ex_2(n=300, mu=[0,0], std=0.25, delta=0.2):\n", + " X = np.random.multivariate_normal(mu, np.diagflat(std*np.ones(2)), n)\n", + " Y = np.zeros((X.shape[0]))\n", + "\n", + " for i in range(X.shape[0]):\n", + " x = X[i,0]\n", + " y = X[i,1]\n", + " if y < x*(x-1)*(x+1):\n", + " Y[i] = -1\n", + " X[i,1] = X[i,1] - delta\n", + " else:\n", + " Y[i] = 1\n", + " X[i,1] = X[i,1] + delta\n", + " return X,Y" + ] + }, + { + "cell_type": "code", + "execution_count": 1049, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "def plot(X,Y,classifier, nameFig):\n", + " minx1 = min(X[:,0])\n", + " maxx1 = max(X[:,0])\n", + " minx2 = min(X[:,1])\n", + " maxx2 = max(X[:,1])\n", + "\n", + " xx = np.linspace(minx1, maxx1, 100)\n", + " yy = np.linspace(minx2, maxx2, 100).T\n", + " xx, yy = np.meshgrid(xx,yy)\n", + " Xfull = np.c_[xx.ravel(), yy.ravel()]\n", + "\n", + " probas = classifier.predict_proba(Xfull)\n", + " Z = classifier.decision_function(Xfull)\n", + "\n", + " k = 1\n", + " plt.title(\"Class %d\" %k)\n", + " imshow_handle = plt.imshow(probas[:, k].reshape((100,100)), extent=(minx1, maxx1, minx2, maxx2), origin='lower')\n", + " \n", + " classPos = Y>=0\n", + " classNeg = Y<0\n", + "\n", + " plt.contour(xx, yy, Z.reshape((100,100)), [-1,0,1], colors=['blue', 'black', 'red'])\n", + " plt.scatter(X[classPos, 0], X[classPos, 1], marker='o', c='r', edgecolors='k')\n", + " plt.scatter(X[classNeg, 0], X[classNeg, 1], marker='o', c='b', edgecolors='k')\n", + "\n", + " ax = plt.axes([0.8, 0.15, 0.05, 0.7])\n", + "\n", + " plt.title('Probability')\n", + " plt.colorbar(imshow_handle, cax=ax, orientation='vertical')\n", + " \n", + " plt.savefig(nameFig+'.jpg', dpi=300)\n", + " plt.show()\n", + " plt.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 1053, + "metadata": {}, + "outputs": [], + "source": [ + "def main(X,Y,nameFig = 'GridSearchCV'):\n", + " parameters = {'kernel':('poly', 'poly'), 'C':[0.1,0.5, 1, 10], 'degree':[3,5], 'coef0':[0, 0.1, 0.5, 1, 10]}\n", + " svc = SVC(probability=True)\n", + " classifier = GridSearchCV(svc, parameters)\n", + " classifier = classifier.fit(X,Y)\n", + " print(classifier.best_params_)\n", + "\n", + " plot(X,Y, classifier=classifier, nameFig=nameFig)" + ] + }, + { + "cell_type": "code", + "execution_count": 1055, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'C': 0.5, 'coef0': 0.5, 'degree': 3, 'kernel': 'poly'}\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "X,Y = genere_ex_2()\n", + "main(X,Y)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reconnaissance de chiffres manuscrits" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/D3/TP/TP_SETI_SVM/plot_digits_classification.ipynb b/D3/TP/TP_SETI_SVM/plot_digits_classification.ipynb new file mode 100644 index 0000000..724476f --- /dev/null +++ b/D3/TP/TP_SETI_SVM/plot_digits_classification.ipynb @@ -0,0 +1,363 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Recognizing hand-written digits\n", + "\n", + "This example shows how scikit-learn can be used to recognize images of\n", + "hand-written digits, from 0-9.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Author: Gael Varoquaux \n", + "# License: BSD 3 clause\n", + "\n", + "# Standard scientific Python imports\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Import datasets, classifiers and performance metrics\n", + "from sklearn import datasets, svm, metrics\n", + "from sklearn.model_selection import train_test_split" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Digits dataset\n", + "\n", + "The digits dataset consists of 8x8\n", + "pixel images of digits. The ``images`` attribute of the dataset stores\n", + "8x8 arrays of grayscale values for each image. We will use these arrays to\n", + "visualize the first 4 images. The ``target`` attribute of the dataset stores\n", + "the digit each image represents and this is included in the title of the 4\n", + "plots below.\n", + "\n", + "Note: if we were working from image files (e.g., 'png' files), we would load\n", + "them using :func:`matplotlib.pyplot.imread`.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "digits = datasets.load_digits()\n", + "\n", + "_, axes = plt.subplots(nrows=1, ncols=4, figsize=(10, 3))\n", + "for ax, image, label in zip(axes, digits.images, digits.target):\n", + " ax.set_axis_off()\n", + " ax.imshow(image, cmap=plt.cm.gray_r, interpolation=\"nearest\")\n", + " ax.set_title(\"Training: %i\" % label)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Classification\n", + "\n", + "To apply a classifier on this data, we need to flatten the images, turning\n", + "each 2-D array of grayscale values from shape ``(8, 8)`` into shape\n", + "``(64,)``. Subsequently, the entire dataset will be of shape\n", + "``(n_samples, n_features)``, where ``n_samples`` is the number of images and\n", + "``n_features`` is the total number of pixels in each image.\n", + "\n", + "We can then split the data into train and test subsets and fit a support\n", + "vector classifier on the train samples. The fitted classifier can\n", + "subsequently be used to predict the value of the digit for the samples\n", + "in the test subset.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# flatten the images\n", + "n_samples = len(digits.images)\n", + "data = digits.images.reshape((n_samples, -1))\n", + "\n", + "# Create a classifier: a support vector classifier\n", + "clf = svm.SVC(gamma=0.001)\n", + "\n", + "# Split data into 50% train and 50% test subsets\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " data, digits.target, test_size=0.5, shuffle=False\n", + ")\n", + "\n", + "# Learn the digits on the train subset\n", + "clf.fit(X_train, y_train)\n", + "\n", + "# Predict the value of the digit on the test subset\n", + "predicted = clf.predict(X_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below we visualize the first 4 test samples and show their predicted\n", + "digit value in the title.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "_, axes = plt.subplots(nrows=1, ncols=4, figsize=(10, 3))\n", + "for ax, image, prediction in zip(axes, X_test, predicted):\n", + " ax.set_axis_off()\n", + " image = image.reshape(8, 8)\n", + " ax.imshow(image, cmap=plt.cm.gray_r, interpolation=\"nearest\")\n", + " ax.set_title(f\"Prediction: {prediction}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + ":func:`~sklearn.metrics.classification_report` builds a text report showing\n", + "the main classification metrics.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Classification report for classifier SVC(gamma=0.001):\n", + " precision recall f1-score support\n", + "\n", + " 0 1.00 0.99 0.99 88\n", + " 1 0.99 0.97 0.98 91\n", + " 2 0.99 0.99 0.99 86\n", + " 3 0.98 0.87 0.92 91\n", + " 4 0.99 0.96 0.97 92\n", + " 5 0.95 0.97 0.96 91\n", + " 6 0.99 0.99 0.99 91\n", + " 7 0.96 0.99 0.97 89\n", + " 8 0.94 1.00 0.97 88\n", + " 9 0.93 0.98 0.95 92\n", + "\n", + " accuracy 0.97 899\n", + " macro avg 0.97 0.97 0.97 899\n", + "weighted avg 0.97 0.97 0.97 899\n", + "\n", + "\n" + ] + } + ], + "source": [ + "print(\n", + " f\"Classification report for classifier {clf}:\\n\"\n", + " f\"{metrics.classification_report(y_test, predicted)}\\n\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also plot a `confusion matrix ` of the\n", + "true digit values and the predicted digit values.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Confusion matrix:\n", + "[[87 0 0 0 1 0 0 0 0 0]\n", + " [ 0 88 1 0 0 0 0 0 1 1]\n", + " [ 0 0 85 1 0 0 0 0 0 0]\n", + " [ 0 0 0 79 0 3 0 4 5 0]\n", + " [ 0 0 0 0 88 0 0 0 0 4]\n", + " [ 0 0 0 0 0 88 1 0 0 2]\n", + " [ 0 1 0 0 0 0 90 0 0 0]\n", + " [ 0 0 0 0 0 1 0 88 0 0]\n", + " [ 0 0 0 0 0 0 0 0 88 0]\n", + " [ 0 0 0 1 0 1 0 0 0 90]]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfIAAAHgCAYAAABej+9AAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB1hklEQVR4nO3deVhUZf8G8HtYh3VYZFU2d3EXzXC3SF5fNbfUzAr3t8JyybXczVD75b5lGS5JZqWWLS5ZbomKKGaiiOKCIpsCwzrAzPn9QYyOaDIMzJlh7s91navmzHPOuTmDfOd5ziYRBEEAERERGSUzsQMQERFR1bGQExERGTEWciIiIiPGQk5ERGTEWMiJiIiMGAs5ERGREWMhJyIiMmIs5EREREaMhZyIiMiIsZATiSwxMRG9evWCTCaDRCLB3r17q3X9N2/ehEQiwZYtW6p1vcasR48e6NGjh9gxiKoFCzkRgOvXr+N///sf6tevD6lUCkdHR3Tu3BmrVq1CYWFhjW47LCwMFy9exOLFi7F9+3a0b9++RrenTyNHjoREIoGjo+MT92NiYiIkEgkkEgn+7//+T+v1p6SkYP78+YiLi6uGtETGyULsAERi+/nnnzFkyBBYW1vjzTffRIsWLVBcXIwTJ05g2rRpuHTpEjZt2lQj2y4sLER0dDQ+/PBDTJgwoUa24efnh8LCQlhaWtbI+p/FwsICBQUF2LdvH4YOHarx3o4dOyCVSlFUVFSldaekpGDBggXw9/dHmzZtKr3cwYMHq7Q9IkPEQk4m7caNG3j11Vfh5+eH33//HV5eXur3wsPDce3aNfz88881tv2MjAwAgJOTU41tQyKRQCqV1tj6n8Xa2hqdO3fG119/XaGQR0VFoU+fPvj+++/1kqWgoAC2trawsrLSy/aI9IFD62TSli1bhry8PGzevFmjiJdr2LAhJk6cqH5dWlqKRYsWoUGDBrC2toa/vz8++OADKBQKjeX8/f3Rt29fnDhxAs899xykUinq16+Pbdu2qdvMnz8ffn5+AIBp06ZBIpHA398fQNmQdPn/P2r+/PmQSCQa8w4dOoQuXbrAyckJ9vb2aNKkCT744AP1+087Rv7777+ja9eusLOzg5OTE/r374/Lly8/cXvXrl3DyJEj4eTkBJlMhlGjRqGgoODpO/Yxr732Gn799VdkZ2er58XExCAxMRGvvfZahfYPHjzA1KlT0bJlS9jb28PR0RG9e/fGhQsX1G2OHDmCDh06AABGjRqlHqIv/zl79OiBFi1aIDY2Ft26dYOtra16vzx+jDwsLAxSqbTCzx8aGgpnZ2ekpKRU+mcl0jcWcjJp+/btQ/369dGpU6dKtR87dizmzp2Ldu3aYcWKFejevTsiIiLw6quvVmh77do1vPLKK3jppZfw6aefwtnZGSNHjsSlS5cAAIMGDcKKFSsAAMOHD8f27duxcuVKrfJfunQJffv2hUKhwMKFC/Hpp5/i5Zdfxp9//vmvy/32228IDQ1Feno65s+fjylTpuDkyZPo3Lkzbt68WaH90KFDkZubi4iICAwdOhRbtmzBggULKp1z0KBBkEgk2L17t3peVFQUmjZtinbt2lVon5SUhL1796Jv375Yvnw5pk2bhosXL6J79+7qotqsWTMsXLgQADB+/Hhs374d27dvR7du3dTruX//Pnr37o02bdpg5cqV6Nmz5xPzrVq1Cm5ubggLC4NSqQQAfPbZZzh48CDWrFkDb2/vSv+sRHonEJmonJwcAYDQv3//SrWPi4sTAAhjx47VmD916lQBgPD777+r5/n5+QkAhGPHjqnnpaenC9bW1sL777+vnnfjxg0BgPDJJ59orDMsLEzw8/OrkGHevHnCo/9sV6xYIQAQMjIynpq7fBuRkZHqeW3atBHc3d2F+/fvq+dduHBBMDMzE958880K2xs9erTGOgcOHCi4uro+dZuP/hx2dnaCIAjCK6+8Irz44ouCIAiCUqkUPD09hQULFjxxHxQVFQlKpbLCz2FtbS0sXLhQPS8mJqbCz1aue/fuAgBh48aNT3yve/fuGvMOHDggABA++ugjISkpSbC3txcGDBjwzJ+RSGzskZPJksvlAAAHB4dKtf/ll18AAFOmTNGY//777wNAhWPpgYGB6Nq1q/q1m5sbmjRpgqSkpCpnflz5sfUffvgBKpWqUsvcu3cPcXFxGDlyJFxcXNTzW7VqhZdeekn9cz7qrbfe0njdtWtX3L9/X70PK+O1117DkSNHkJqait9//x2pqalPHFYHyo6rm5mV/XlSKpW4f/+++rDBuXPnKr1Na2trjBo1qlJte/Xqhf/9739YuHAhBg0aBKlUis8++6zS2yISCws5mSxHR0cAQG5ubqXa37p1C2ZmZmjYsKHGfE9PTzg5OeHWrVsa8319fSusw9nZGVlZWVVMXNGwYcPQuXNnjB07Fh4eHnj11Vexa9eufy3q5TmbNGlS4b1mzZohMzMT+fn5GvMf/1mcnZ0BQKuf5b///S8cHBzwzTffYMeOHejQoUOFfVlOpVJhxYoVaNSoEaytrVGnTh24ubnhr7/+Qk5OTqW3WbduXa1ObPu///s/uLi4IC4uDqtXr4a7u3ullyUSCws5mSxHR0d4e3vj77//1mq5x082expzc/MnzhcEocrbKD9+W87GxgbHjh3Db7/9hjfeeAN//fUXhg0bhpdeeqlCW13o8rOUs7a2xqBBg7B161bs2bPnqb1xAPj4448xZcoUdOvWDV999RUOHDiAQ4cOoXnz5pUeeQDK9o82zp8/j/T0dADAxYsXtVqWSCws5GTS+vbti+vXryM6OvqZbf38/KBSqZCYmKgxPy0tDdnZ2eoz0KuDs7Ozxhne5R7v9QOAmZkZXnzxRSxfvhzx8fFYvHgxfv/9d/zxxx9PXHd5zoSEhArvXblyBXXq1IGdnZ1uP8BTvPbaazh//jxyc3OfeIJgue+++w49e/bE5s2b8eqrr6JXr14ICQmpsE8q+6WqMvLz8zFq1CgEBgZi/PjxWLZsGWJiYqpt/UQ1hYWcTNr06dNhZ2eHsWPHIi0trcL7169fx6pVqwCUDQ0DqHBm+fLlywEAffr0qbZcDRo0QE5ODv766y/1vHv37mHPnj0a7R48eFBh2fIbozx+SVw5Ly8vtGnTBlu3btUojH///TcOHjyo/jlrQs+ePbFo0SKsXbsWnp6eT21nbm5eobf/7bff4u7duxrzyr9wPOlLj7ZmzJiB27dvY+vWrVi+fDn8/f0RFhb21P1IZCh4QxgyaQ0aNEBUVBSGDRuGZs2aadzZ7eTJk/j2228xcuRIAEDr1q0RFhaGTZs2ITs7G927d8eZM2ewdetWDBgw4KmXNlXFq6++ihkzZmDgwIF47733UFBQgA0bNqBx48YaJ3stXLgQx44dQ58+feDn54f09HSsX78e9erVQ5cuXZ66/k8++QS9e/dGcHAwxowZg8LCQqxZswYymQzz58+vtp/jcWZmZpg9e/Yz2/Xt2xcLFy7EqFGj0KlTJ1y8eBE7duxA/fr1Ndo1aNAATk5O2LhxIxwcHGBnZ4eOHTsiICBAq1y///471q9fj3nz5qkvh4uMjESPHj0wZ84cLFu2TKv1EemVyGfNExmEq1evCuPGjRP8/f0FKysrwcHBQejcubOwZs0aoaioSN2upKREWLBggRAQECBYWloKPj4+wqxZszTaCELZ5Wd9+vSpsJ3HL3t62uVngiAIBw8eFFq0aCFYWVkJTZo0Eb766qsKl58dPnxY6N+/v+Dt7S1YWVkJ3t7ewvDhw4WrV69W2Mbjl2j99ttvQufOnQUbGxvB0dFR6NevnxAfH6/Rpnx7j1/eFhkZKQAQbty48dR9Kgial589zdMuP3v//fcFLy8vwcbGRujcubMQHR39xMvGfvjhByEwMFCwsLDQ+Dm7d+8uNG/e/InbfHQ9crlc8PPzE9q1ayeUlJRotJs8ebJgZmYmREdH/+vPQCQmiSBocbYKERERGRQeIyciIjJiLORERERGjIWciIjIiLGQExERGTEWciIiIiPGQk5ERGTEWMiJiIiMGAs5ERGREWMhJyIiMmIs5EREREaMhZyIiMiIsZATEREZMRZyIiIiI8ZCTkREZMRYyImIiIwYCzkREZERYyEnIiIyYizkRERERoyFnIiIyIixkBMRERkxFnIiIiIjxkJORERkxFjIiYiIjBgLORERkRFjISciIjJiLORERERGjIWciIjIiLGQExERGTEWciIiIiPGQk5ERFRDcnNzMWnSJPj5+cHGxgadOnVCTEyM+n1BEDB37lx4eXnBxsYGISEhSExM1GobLOREREQ1ZOzYsTh06BC2b9+OixcvolevXggJCcHdu3cBAMuWLcPq1auxceNGnD59GnZ2dggNDUVRUVGltyERBEGoqR+gpqlUKqSkpMDBwQESiUTsOEREpCVBEJCbmwtvb2+YmdVc37KoqAjFxcU6r0cQhAr1xtraGtbW1hXaFhYWwsHBAT/88AP69Omjnh8UFITevXtj0aJF8Pb2xvvvv4+pU6cCAHJycuDh4YEtW7bg1VdfrVQmCx1+HtGlpKTAx8dH7BhERKSj5ORk1KtXr0bWXVRUhAA/e6SmK3Vel729PfLy8jTmzZs3D/Pnz6/QtrS0FEqlElKpVGO+jY0NTpw4gRs3biA1NRUhISHq92QyGTp27Ijo6GjTKOQODg4AgPMxbnCwN5yjBGObPS92BKoqM3OxE1Sk0v2PD5GhKkUJTuAX9d/zmlBcXIzUdCVuxfrD0aHqtUKeq4Jf0E0kJyfD0dFRPf9JvXGgrEYFBwdj0aJFaNasGTw8PPD1118jOjoaDRs2RGpqKgDAw8NDYzkPDw/1e5Vh1IW8fHjDwd4MDjp8ONXNQmIpdgSqKokBFnKJ4fxuE1W7fw7u6uPwqL2DBPYOVd+OCmXLOjo6ahTyf7N9+3aMHj0adevWhbm5Odq1a4fhw4cjNja2yjkex78QRERkEpSCSudJWw0aNMDRo0eRl5eH5ORknDlzBiUlJahfvz48PT0BAGlpaRrLpKWlqd+rDBZyIiIyCSoIOk9VZWdnBy8vL2RlZeHAgQPo378/AgIC4OnpicOHD6vbyeVynD59GsHBwZVet1EPrRMRERmyAwcOQBAENGnSBNeuXcO0adPQtGlTjBo1ChKJBJMmTcJHH32ERo0aISAgAHPmzIG3tzcGDBhQ6W2wkBMRkUlQQQXtB8c1l9dWTk4OZs2ahTt37sDFxQWDBw/G4sWLYWlZdi7V9OnTkZ+fj/HjxyM7OxtdunTB/v37K5zp/m+M+jpyuVwOmUyGa5c9DOpktxE+ncWOQFXFs9aJ9KpUKMER/ICcnJxKn0CmrfJakXylrs5nrfs0vVujWavCcKofERERaY1D60REZBJ0PWFNl2VrEgs5ERGZBBUEKGthIefQOhERkRFjj5yIiEwCh9ZrAZUS+H65L/7c44bsdEs4exSj25B0DJh4B+V3B3zaGefDP7yJvm/d1VvWfiMz8crb6XBxK0VSvA3Wz66LhDhbvW2fmaqmRcdcDHkrDY1aFsLVswTzx9RH9AEn0fKUM7T9xEzMJAalIECpw4Vauixbk0xqaH3f+nr4bbsnwhYl4ZM/zuPVD27hp431cCDSS91mXewZjWn8/yVCIhHwXO9MveXs/nIWxs9LwY7lnggPbYykeCkWRyVB5lqitwzMVDVSWxWS4m2xdrbhPJXPEPcTMzETVR+DKOTr1q2Dv78/pFIpOnbsiDNnztTIdq7GOiCo1wO0fTELbj4KdOxzHy27ZSEpzl7dxsm9RGOKPeiCwE45cPdT1EimJxk0PhP7o1xw8BsX3E6UYvWMelAUShA6/IHeMjBT1Zz9Q4atn3jj5H4n0TI8zhD3EzMxkxhU1TAZItEL+TfffIMpU6Zg3rx5OHfuHFq3bo3Q0FCkp6dX+7YaB+Xi0p8y3Esqu2POrXhbJMQ4onXP7Ce2z8mwRNzvzug+LO2J79cEC0sVGrUqwLnjDx/pJwgSnD/ugMCgAr3lYKbawRD3EzMxk1iU/5y1rstkiEQv5MuXL8e4ceMwatQoBAYGYuPGjbC1tcWXX35Z7dvqF34HwS9nYlqPdngzIBgf/qcN/jMmBZ0HZjyx/bHv3CG1U6JD7/vVnuVpHF2UMLcAsjM0T1/IyrSAs1up3nIwU+1giPuJmZhJLEpB98kQiXqyW3FxMWJjYzFr1iz1PDMzM4SEhCA6OrpCe4VCAYXi4RC3XC7Xanun99XBn3vcEL7mKuo2LsCteDt8NT/gn5PeKhbzo9+4o/PADFhJDfTTIyIikydqjzwzMxNKpRIeHh4a8z08PJCamlqhfUREBGQymXry8dHuhKKoxf7o984dBPfPhG+zAnQdnIH/jE3Bj+vqVWh75bQj7l23RY/h+htWBwD5A3MoSwGnx77dOtcpRVaGON+7mMl4GeJ+YiZmEguPkRuAWbNmIScnRz0lJydrtXxxoRnMHvuJzcwFCCpJhbZHdrojoGUe/AL1e9yntMQMiX/Zom2XXPU8iURAmy55iI8V5/IOZjJehrifmImZxKKCBEodJhUq1gpDIOpXqDp16sDc3BxpaZq93rS0NHh6elZob21tDWtr6ypvr23IA+xdUw+udRWo17gAN/+2w6+f161wMltBrjnO/FwHr825WeVt6WL3pjqYujIZVy/YIuG8LQaOy4DUVoWDO11EycNMlSe1VcLb/+HhH08fBeoHFiA32wIZKVaiZDLE/cRMzETVR9RCbmVlhaCgIBw+fFj9EHWVSoXDhw9jwoQJ1b69sEU38N3/+SLyw/qQZ5bdEOaFEakYNEmzZ3/qxzoQBKBT/yefBFfTjv7oDJmrEm9OS4WzWymSLtngwxEByM60FCUPM1Ve49YF+OTbRPXrt+aX3UTo4C4XfDrFX5RMhrifmImZxKASyiZdljdEoj+P/JtvvkFYWBg+++wzPPfcc1i5ciV27dqFK1euVDh2/jg+j5yqHZ9HTqRX+nwe+elLnrDXoVbk5arQsXmqwT2PXPSzE4YNG4aMjAzMnTsXqampaNOmDfbv3//MIk5EREQGUMgBYMKECTUylE5ERFSu/KQ1XZY3RAZRyImIiGqaSpBAJVS9GOuybE0ynAPLREREpDX2yImIyCRwaJ2IiMiIKWEGpQ4D0YZ6/QgLORERmQRBx2PkAo+RExERUXVjj5yIiEwCj5ETEREZMaVgBqWgwzFyA71FK4fWiYiIjBh75EREZBJUkEClQ/9VBcPskrOQExGRSeAxcgM2ttnzsJAYziP0vr9zSuwIFQz2NcAnshniU70MMRMZL0N8mp6hEVSASuwQxo3HyImIyCSUn+ymy6TV9pRKzJkzBwEBAbCxsUGDBg2waNEiPPr0cEEQMHfuXHh5ecHGxgYhISFITEzUajss5EREZBLKjpHrNmlj6dKl2LBhA9auXYvLly9j6dKlWLZsGdasWaNus2zZMqxevRobN27E6dOnYWdnh9DQUBQVFVV6O7ViaJ2IiEhf5HK5xmtra2tYW1tXaHfy5En0798fffr0AQD4+/vj66+/xpkzZwCU9cZXrlyJ2bNno3///gCAbdu2wcPDA3v37sWrr75aqTzskRMRkUlQ/XOv9apO5We8+/j4QCaTqaeIiIgnbq9Tp044fPgwrl69CgC4cOECTpw4gd69ewMAbty4gdTUVISEhKiXkclk6NixI6Kjoyv9c7FHTkREJkH3G8KUHdtOTk6Go6Ojev6TeuMAMHPmTMjlcjRt2hTm5uZQKpVYvHgxRowYAQBITU0FAHh4eGgs5+HhoX6vMljIiYjIJKge6VVXbfmyQu7o6KhRyJ9m165d2LFjB6KiotC8eXPExcVh0qRJ8Pb2RlhYWJVzPI6FnIiIqAZMmzYNM2fOVB/rbtmyJW7duoWIiAiEhYXB09MTAJCWlgYvLy/1cmlpaWjTpk2lt8Nj5EREZBKUgkTnSRsFBQUwM9Mss+bm5lCpyi6cDwgIgKenJw4fPqx+Xy6X4/Tp0wgODq70dtgjJyIik1B+0lrVl9fuFq39+vXD4sWL4evri+bNm+P8+fNYvnw5Ro8eDQCQSCSYNGkSPvroIzRq1AgBAQGYM2cOvL29MWDAgEpvh4WciIioBqxZswZz5szBO++8g/T0dHh7e+N///sf5s6dq24zffp05OfnY/z48cjOzkaXLl2wf/9+SKXSSm9HIjx6ixkjI5fLIZPJ0AP9eYvWZ+AtWolEwFu0PlOpUIIjqt3Iycmp1AlkVVFeK7481xa2DlX/TApylRjd7nyNZq0K9siJiMgk6HtoXV9YyAH0G5mJV95Oh4tbKZLibbB+dl0kxNnqZdtKJbBreT0c210H2elWcPYsRs8hGXhl4l1I/jmvojDfDF997IszB5yRl2UJd98i/Hd0KkLfSNdLRgBo0TEXQ95KQ6OWhXD1LMH8MfURfcBJb9t/GjE/O2ZipppkiP/mDDET8ax1dH85C+PnpWDHck+EhzZGUrwUi6OSIHMt0cv29673xoFtHhj70U2sOnIBb8y6jb0bvPHLl57qNlsW+CHuiBMmrr6OVUcuoM+YVHwxOwAxB531khEApLYqJMXbYu1sH71t81nE/uyYiZlqkiH+mzPETNpQQbcz1w31IW2iFvJjx46hX79+8Pb2hkQiwd69e/WeYdD4TOyPcsHBb1xwO1GK1TPqQVEoQejwB3rZfsJZB3TolYWgF7Ph7qNAcN8HaN0tG9fi7B62iXVAjyEZaNFJDncfBXq9ng7/wHwkPtKmpp39Q4atn3jj5H4nvW3zWcT+7JiJmWqSIf6bM8RM2ii/IYwukyESNVV+fj5at26NdevWibJ9C0sVGrUqwLnjDup5giDB+eMOCAwq0EuGJu1zcfFPGVKSys5QvBlviysxDmjbM/thm6BcxBxyxv17lhAE4OKfjkhJskHrbjl6yWiIDOGzYyZmIjIEoh4j7927t/rm8WJwdFHC3ALIztDcDVmZFvBpqNBLhoHhKSjINcd73VvDzFyASinBazOS0W3QfXWbsYtuYuOM+hjfIQjmFipIzIC3lyWh+fO5esloiAzhs2MmZiLjovu91g2zR25UJ7spFAooFA//UT3+KDljdHKfK47vqYNJa6/Bp3EBblyyQ+R8Pzh7FKPnkEwAwC+Rnrh6zh4zI6/ArW4x4k874PMPA+DsUYzWXY1/HxAR6UNVnin++PKGyKgKeUREBBYsWFBt65M/MIeyFHByK9WY71ynFFkZ+tk12z7yxcDwFHTpX9YD92tWiMy71ti9ti56DsmEolCCqKU+mP7FVQS9mA0A8A8swM1Ldvhxo7fJFnJD+OyYiZnIuNTWHrlhpnqKWbNmIScnRz0lJyfrtL7SEjMk/mWLtl0eDlFLJALadMlDfKx+LjlRFJpB8tinYGYuQPjn9EhlqRlKS8zUl6JptDHMSxr1whA+O2ZiJiJDYFRfNa2trZ/63Neq2r2pDqauTMbVC7ZIOG+LgeMyILVV4eBOl2rdztO0fykb36/2hltdBXwaF+LG37bYt8kLLwzLAADYOijR/Hk5ti32hZVUBbd6Clw65Yij37khbN4tvWQEAKmtEt7+Dw9rePooUD+wALnZFshIsdJbjkeJ/dkxEzPVJEP8N2eImbSh+w1hDLPva1SFvCYc/dEZMlcl3pyWCme3UiRdssGHIwKQnamfW76OXXQDX3/ig00fBECeaQlnz2K89Hoahky6q24zeX0idizxwap3GyIv2wJ16ikwfMZthL6RppeMANC4dQE++TZR/fqt+WX5Du5ywadT/PWW41Fif3bMxEw1yRD/zRliJm2oBAlUWj7B7PHlDZGo91rPy8vDtWvXAABt27bF8uXL0bNnT7i4uMDX1/eZy/Ne65XHe60TiYD3Wn8mfd5rfVlMV9jYV73/WphXiukdjvNe6486e/YsevbsqX49ZcoUAEBYWBi2bNkiUioiIqqNVDoOrRvqDWFELeQ9evSAET98jYiIjIhKMINKhzPPdVm2JhlmKiIiIqoUkz/ZjYiITIMSEih1uKmLLsvWJBZyIiIyCRxaJyIiIoPDHjkREZkEJXQbHjfUC2ZZyImIyCTU1qF1FnIiIjIJfGgKERERGRz2yImIyCQIOj6PXODlZ0REROLh0DoREREZHPbIa8Dges+LHaGC9beOih2hgncCuosdoSI+kY2qE3+fnk3Q3z6qrY8xZSEnIiKToNTx6We6LFuTDDMVERERVQp75EREZBI4tE5ERGTEVDCDSoeBaF2WrUmGmYqIiMjI+fv7QyKRVJjCw8MBAEVFRQgPD4erqyvs7e0xePBgpKWlab0dFnIiIjIJSkGi86SNmJgY3Lt3Tz0dOnQIADBkyBAAwOTJk7Fv3z58++23OHr0KFJSUjBo0CCtfy4OrRMRkUmormPkcrlcY761tTWsra0rtHdzc9N4vWTJEjRo0ADdu3dHTk4ONm/ejKioKLzwwgsAgMjISDRr1gynTp3C889X/jJm9siJiMgkCP88/ayqk/DPnd18fHwgk8nUU0RExDO3XVxcjK+++gqjR4+GRCJBbGwsSkpKEBISom7TtGlT+Pr6Ijo6Wqufiz1yIiIiLSQnJ8PR0VH9+km98cft3bsX2dnZGDlyJAAgNTUVVlZWcHJy0mjn4eGB1NRUrfKwkBMRkUlQQgKlDg8+KV/W0dFRo5BXxubNm9G7d294e3tXeftPw0JOREQmQSXodi24Sqjacrdu3cJvv/2G3bt3q+d5enqiuLgY2dnZGr3ytLQ0eHp6arV+HiMnIiKqQZGRkXB3d0efPn3U84KCgmBpaYnDhw+r5yUkJOD27dsIDg7Wav3skQPoNzITr7ydDhe3UiTF22D97LpIiLM12UwqJfDzCl+c2eMOeYYlZB7FeP6VdPR+LxmSf77Mbnu/EU5956GxXGD3LEzYdkkvGQGgRcdcDHkrDY1aFsLVswTzx9RH9AEnvW3/afj7xEzMZJjKT1rTZXmtl1GpEBkZibCwMFhYPCy5MpkMY8aMwZQpU+Di4gJHR0e8++67CA4O1uqMdYA9cnR/OQvj56Vgx3JPhIc2RlK8FIujkiBzLTHZTAc31MOxr7wwdOF1zD18DgNm3sShz+riyBYvjXaB3R8gIua0ehq95ope8pWT2qqQFG+LtbN99LrdfyP2Z8dMzGSKmSpLBYnOk7Z+++033L59G6NHj67w3ooVK9C3b18MHjwY3bp1g6enp8bwe2WJWsgjIiLQoUMHODg4wN3dHQMGDEBCQoJeMwwan4n9US44+I0LbidKsXpGPSgKJQgd/kCvOQwpU1KsI1q9dB8tX8yCq48C7frcR7Ou2bgZ56DRzsJagMy9RD3ZyvT7yMazf8iw9RNvnNzvpNft/huxPztmYiZTzGTIevXqBUEQ0Lhx4wrvSaVSrFu3Dg8ePEB+fj52796t9fFxQORCfvToUYSHh+PUqVM4dOgQSkpK0KtXL+Tn5+tl+xaWKjRqVYBzxx8WKEGQ4PxxBwQGFeglgyFmqh8kR8JJJ6QlSQEAd+LtcP2sI5r3yNJol3hKhuntnsP8nu3w9YcNkJdl2kdqDOGzYyZmMrVM2tD3nd30RdS/vPv379d4vWXLFri7uyM2NhbdunWr8e07uihhbgFkZ2juhqxMC/g0VNT49g01U6937qAozxwLXwiCxFyAoJSg37RbeG5ghrpNYPcstPnPfbj6FCHjlhQ/LvPHurDmmLbnAszM9RLT4BjCZ8dMzGRqmbQhxjFyfTCoLlROTg4AwMXF5YnvKxQKKBQPf1kev00eVY9zP9XBmb3uGLU6AV6NC3An3g7fLagPp39OegOA9i9nqtvXbVqAes3yMbdrB1yNlqFplxyxohMRmRyD+XqhUqkwadIkdO7cGS1atHhim4iICI3b4vn46HaSk/yBOZSlgJNbqcZ85zqlyMoQ5zuOIWTa/XEAQt++g/YvZ6Ju0wJ0HJSBF8ak4MD6ek9dpo6vAvYuJci4ZaOXjIbIED47ZmImU8ukDRUk6vutV2nS4WYyNclgCnl4eDj+/vtv7Ny586ltZs2ahZycHPWUnJys0zZLS8yQ+Jct2nbJVc+TSAS06ZKH+FhxLqUwhEwlhWaQmGne+UBiLkBQPf2XOOueFfKzLCBzL67peAbLED47ZmImU8ukDUHHM9YFAy3kBvEVasKECfjpp59w7Ngx1Kv39F7f054wo4vdm+pg6spkXL1gi4Tzthg4LgNSWxUO7nzy8L4+iJ2pZcgD7F/rA2dvBbwbFyD5kj1+/6IugoeWPSe3KN8Mv6z0Rdve9+HoVoyMW1LsiQiAm38RmnXLesbaq4/UVglv/4eHWjx9FKgfWIDcbAtkpFjpLcejxP7smImZTDFTZVXX088MjaiFXBAEvPvuu9izZw+OHDmCgIAAvWc4+qMzZK5KvDktFc5upUi6ZIMPRwQgO9NS71kMJdPQBUnY96kvvpnTALmZZTeE6fLaPfx3YtkIiJk5cPeKHU59745CuQVkHsVo1jUb/d6/BUvrKt7DsAoaty7AJ98mql+/Nf8uAODgLhd8OsVfbzkeJfZnx0zMZIqZTJ1EEAT9/eV9zDvvvIOoqCj88MMPaNKkiXq+TCaDjc2zj7XK5XLIZDL0QH9YSPhL9G/W3zohdoQK3gnoLnaEilT6vRaeyNSVCiU4gh+Qk5Oj9YNIKqu8Vgw8NAqWdlUfrSvJL8aelyJrNGtViNoj37BhAwCgR48eGvMjIyPVj3ojIiKqDhxarwEiDgYQERHVCgZxshsREVFNq+r90h9d3hCxkBMRkUmorUPrBnMdOREREWmPPXIiIjIJtbVHzkJOREQmobYWcg6tExERGTH2yImIyCTU1h45CzkREZkEAbpdQmaodz5hISciIpNQW3vkPEZORERkxNgjJyIik1Bbe+Qs5CbiHb8uYkeo4O3EBLEjVLChUUOxI1RgZmcndoQKVPn5YkeowNxJJnaEiiwM70+sMvO+2BFEU1sLOYfWiYiIjJjhfV0kIiKqAbW1R85CTkREJkEQJBB0KMa6LFuTOLRORERkxNgjJyIik8DnkRMRERmx2nqMnEPrRERERow9ciIiMgk82Y2IiMiIlQ+t6zJp6+7du3j99dfh6uoKGxsbtGzZEmfPnlW/LwgC5s6dCy8vL9jY2CAkJASJiYlabYOFnIiITEJ5j1yXSRtZWVno3LkzLC0t8euvvyI+Ph6ffvopnJ2d1W2WLVuG1atXY+PGjTh9+jTs7OwQGhqKoqKiSm+HQ+tERERakMvlGq+tra1hbW1dod3SpUvh4+ODyMhI9byAgAD1/wuCgJUrV2L27Nno378/AGDbtm3w8PDA3r178eqrr1YqD3vkRERkEgQdh9XLe+Q+Pj6QyWTqKSIi4onb+/HHH9G+fXsMGTIE7u7uaNu2LT7//HP1+zdu3EBqaipCQkLU82QyGTp27Ijo6OhK/1zskQPoNzITr7ydDhe3UiTF22D97LpIiLNlJgPK9FUPP+Tetawwv/mIbHSbn4mcWxaIXloH987aQFksgW+3fHSZmwnbOkq95HuUIX12fV5LRZ/hqfCopwAA3Eq0QdRaH5w95vyMJWueIe2nxw0ZexujptzE3m11sWlJA1EyjHg7CSPevqkxL/mGLf7X/3lR8jzKkD+7fyMAEATdlgeA5ORkODo6quc/qTcOAElJSdiwYQOmTJmCDz74ADExMXjvvfdgZWWFsLAwpKamAgA8PDw0lvPw8FC/Vxkm3yPv/nIWxs9LwY7lnggPbYykeCkWRyVB5lrCTAaUafD3yQg7eUM99dtyFwDQoHc+Sgok+GlUXQDAy9vvYuA3d6AskeDX/3lBUOklnprY++lxmalWiPw/P7w7oBXeG9gKF6JlmLvhCnwbFoiSp5yh7adHNWqRi95D7yHpivhPnbt5zQ4jenZWT9PC2okdyaA/O31xdHTUmJ5WyFUqFdq1a4ePP/4Ybdu2xfjx4zFu3Dhs3LixWvOIWsg3bNiAVq1aqXdGcHAwfv31V71mGDQ+E/ujXHDwGxfcTpRi9Yx6UBRKEDr8gV5zMNO/s3FVwdZNqZ5u/mEHR99ieD9XiNRYKXLvWuCFpWlwbVIM1ybFeGFZOtIvWuNutI1e8pUTez897vTvLog56oyUWza4e9MGW1f4oajAHE3b5IqSp5yh7adyUlslpi+7gtXzGiNPLv6ApbJUgqz71upJnm0ldiSD/ewqo/zObrpM2vDy8kJgYKDGvGbNmuH27dsAAE9PTwBAWlqaRpu0tDT1e5UhaiGvV68elixZgtjYWJw9exYvvPAC+vfvj0uXLull+xaWKjRqVYBzxx3U8wRBgvPHHRAYJE6PhZmeTVkMJP7ogKav5EIiAZTFEkACmFs9HDOzsFJBYgbci9VfITe0/fQ4MzMB3ftkQmqrxJU4h2cvUEMMeT+9MzsRZ466IC5a/EMPAFDXrwDbfzuBzb+cxLSIS3DzrPyZzDXBkD+7ytD3WeudO3dGQkKCxryrV6/Cz88PQNmJb56enjh8+LD6fblcjtOnTyM4OLjS2xH1K2e/fv00Xi9evBgbNmzAqVOn0Lx58wrtFQoFFAqF+vXjZw5qy9FFCXMLIDtDczdkZVrAp6HiKUvVLGZ6thu/2UMhN0PTQWWfv0ebIljaqBD9SR10fP8+IACn/s8VglKCgnRzveUytP1Uzr9xPpbvuggraxUKC8yx6J2muH1NvOOZhrqfuvVOR8PAPEwcKv7wNQAkXJRh+exA3LlpCxc3BV576wY+2RKLtwd1RGGBOH+6DfWzM1STJ09Gp06d8PHHH2Po0KE4c+YMNm3ahE2bNgEAJBIJJk2ahI8++giNGjVCQEAA5syZA29vbwwYMKDS2xF/7OgfSqUS3377LfLz85/6TSQiIgILFizQczIyNFe+dYRvtwLYeZSdyGbjqkKv1ak4Ns8dF7fJIDEDGvXNRZ3mRTwLBMCdGzYIf7k17ByU6PKf+3h/WSKmj2ghajE3NHU8i/C/Wdfx4diWKCk2jF+asydc1f9/M9EeCRcdsWX/SXQNTcfBPd4iJjNeKkECiR7vtd6hQwfs2bMHs2bNwsKFCxEQEICVK1dixIgR6jbTp09Hfn4+xo8fj+zsbHTp0gX79++HVCqt9HZEL+QXL15EcHAwioqKYG9vjz179lQ4plBu1qxZmDJlivq1XC6Hj49Plbctf2AOZSng5FaqMd+5TimyMsTZNcz073LvWuDOSRuErtM8o9OnayFG/H4LhQ/MYGYBWDuqsCXYH44+eXrLZkj76VGlJWa4d7vsEMO1S/Zo3DIP/cPuYc0ccc7GNsT91Kh5HpzrlGDNd+fU88wtgBbtc9Dvtbvo36YrVCpxb8+Zn2uJu7ds4e1TKFoGQ/zstCEIOp61XoVl+/bti759+z71fYlEgoULF2LhwoVVziX6V88mTZogLi4Op0+fxttvv42wsDDEx8c/sa21tXWFswV1UVpihsS/bNG2y8MTfyQSAW265CE+VpzeCjP9uyvfO8LGVQm/HvlPfN/GRQVrRxXuRNug8L45/F98cruaYEj76d9IzARYWun5dP5HGOJ+iot2wtsvB2HCoIfT1Yv2OPKTOyYMChK9iAOA1KYUXj6FeJAp3glvhvjZkQH0yK2srNCwYUMAQFBQEGJiYrBq1Sp89tlnetn+7k11MHVlMq5esEXCeVsMHJcBqa0KB3e66GX7zFR5ggq48r0DmgzMhdljv7lXvnOAU4Ni2LgokRYnxYmP3NB6VDac6+v3khhD2E+PGvn+LZw95oT0FGvY2inRo18mWnWUY/boJ4966Yuh7afCAgvcuqb5S1VUaA55tiVuXRPnMrQx7yfi9JE6SL8nhatbMV5/JwkqpQRHfvV49sI1yNA+O23U1oemiF7IH6dSqTROaKtpR390hsxViTenpcLZrRRJl2zw4YgAZGdWvPkIM4mb6c6fNshLsUTTVyqe5Jh9wwqnPnWFIsccDnVLEPR2FlqNytZbtnKGsJ8e5eRagqnLrsHFvRj5uea4ccUOs0cH4vyfTqLkKWdo+8kQ1XFXYMbSS3B0KkFOlhUunZNh8utBkGeJewmaMX92tbWQSwRBlyMGupk1axZ69+4NX19f5ObmIioqCkuXLsWBAwfw0ksvPXN5uVwOmUyGHugPC4nh/xKRprcTr4kdoYINjRqKHaECMzvxb0zyOFW+/g5ZVJa5k0zsCBVZGFxfCcrM+2JH0FAqlOAIfkBOTo7Oh0ufprxWNImaCXPbJ9+8pTKUBQokvLakRrNWhai/Zenp6XjzzTdx7949yGQytGrVqtJFnIiIiEQu5Js3bxZz80REZELEOGtdHwxv3IeIiKgGlBVyXY6RV2OYaiT65WdERERUdeyRExGRSaitZ62zkBMRkUkQ8PCZ4lVd3hBxaJ2IiMiIsUdOREQmgUPrRERExqyWjq2zkBMRkWnQsUcOA+2R8xg5ERGREWOPnIiITALv7EZERGTEeLIbUTUzxCeNfX/nlNgRKhhc73mxIxgFZXaO2BGMgqE9JU4QioFssVMYNxZyIiIyDYJEtxPW2CMnIiIST209Rs6z1omIiIwYe+RERGQaeEMYIiIi42XSZ63/+OOPlV7hyy+/XOUwREREpJ1KFfIBAwZUamUSiQRKpVKXPERERDXHQIfHdVGpQq5SqWo6BxERUY2qrUPrOp21XlRUVF05iIiIapZQDZMB0rqQK5VKLFq0CHXr1oW9vT2SkpIAAHPmzMHmzZurPSARERE9ndaFfPHixdiyZQuWLVsGKysr9fwWLVrgiy++qNZwRERE1UdSDZPh0bqQb9u2DZs2bcKIESNgbm6unt+6dWtcuXKlWsMRERFVGw6tl7l79y4aNqz4sAuVSoWSkpJqCaVv/UZmYuvpeOxL+gurfkpEkzYFYkdiJiPIpFQCX39SD28Ht8HwBs/hnc5t8O3Kuhq3cSzMN8PnH/pjXPu2GN7gOUzs2QoHtrvrLWM5fnbMVBOGjL2NX+KPYfzM62JHMUjz58+HRCLRmJo2bap+v6ioCOHh4XB1dYW9vT0GDx6MtLQ0rbejdSEPDAzE8ePHK8z/7rvv0LZtW60DiK37y1kYPy8FO5Z7Ijy0MZLipVgclQSZq3hfSpjJODLtXe+NA9s8MPajm1h15ALemHUbezd445cvPdVttizwQ9wRJ0xcfR2rjlxAnzGp+GJ2AGIOOuslIyD+fmKm2pWpXKMWueg99B6SrtiJHaXyROiRN2/eHPfu3VNPJ06cUL83efJk7Nu3D99++y2OHj2KlJQUDBo0SOttaF3I586diwkTJmDp0qVQqVTYvXs3xo0bh8WLF2Pu3LlaByi3ZMkSSCQSTJo0qcrrqIpB4zOxP8oFB79xwe1EKVbPqAdFoQShwx/oNQczGV+mhLMO6NArC0EvZsPdR4Hgvg/Quls2rsU9/MOWEOuAHkMy0KKTHO4+CvR6PR3+gflIjNPfHz+x9xMz1a5MACC1VWL6sitYPa8x8uRGdIPQ8qef6TIBkMvlGpNCoXjqJi0sLODp6ame6tSpAwDIycnB5s2bsXz5crzwwgsICgpCZGQkTp48iVOntHucstaFvH///ti3bx9+++032NnZYe7cubh8+TL27duHl156SdvVAQBiYmLw2WefoVWrVlVavqosLFVo1KoA5447qOcJggTnjzsgMEic4StmMp5MTdrn4uKfMqQkSQEAN+NtcSXGAW17Zj9sE5SLmEPOuH/PEoIAXPzTESlJNmjdTT/PzjaE/cRMtSdTuXdmJ+LMURfERetvZMmQ+Pj4QCaTqaeIiIintk1MTIS3tzfq16+PESNG4Pbt2wCA2NhYlJSUICQkRN22adOm8PX1RXR0tFZ5qvRVqmvXrjh06FBVFq0gLy8PI0aMwOeff46PPvroX9sqFAqNbz5yuVynbTu6KGFuAWRnaO6GrEwL+DR8+jesmsRMxpNpYHgKCnLN8V731jAzF6BSSvDajGR0G3Rf3WbsopvYOKM+xncIgrmFChIz4O1lSWj+fK5eMhrCfmKm2pMJALr1TkfDwDxMHNpOtAxVVV2PMU1OToajo6N6vrW19RPbd+zYEVu2bEGTJk1w7949LFiwAF27dsXff/+N1NRUWFlZwcnJSWMZDw8PpKamapWrymMiZ8+exeXLlwGUHTcPCgqq0nrCw8PRp08fhISEPLOQR0REYMGCBVXaDlF1O7nPFcf31MGktdfg07gANy7ZIXK+H5w9itFzSCYA4JdIT1w9Z4+ZkVfgVrcY8acd8PmHAXD2KEbrrrp9ESXStzqeRfjfrOv4cGxLlBQb4VOwq+npZ46OjhqF/Gl69+6t/v9WrVqhY8eO8PPzw65du2BjY6NDEE1aF/I7d+5g+PDh+PPPP9XfJLKzs9GpUyfs3LkT9erVq/S6du7ciXPnziEmJqZS7WfNmoUpU6aoX8vlcvj4+GiV/1HyB+ZQlgJObqUa853rlCIrQ5zjPsxkPJm2feSLgeEp6NK/rAfu16wQmXetsXttXfQckglFoQRRS30w/YurCHoxGwDgH1iAm5fs8ONGb70UckPYT8xUezI1ap4H5zolWPPdOfU8cwugRfsc9HvtLvq36QqVyjCvtTYETk5OaNy4Ma5du4aXXnoJxcXFyM7O1uiVp6WlwdPT8+kreQKtv1KNHTsWJSUluHz5Mh48eIAHDx7g8uXLUKlUGDt2bKXXk5ycjIkTJ2LHjh2QSqWVWsba2lr9Taiy34j+TWmJGRL/skXbLg+HOSUSAW265CE+1landTNT7c+kKDSD5LF/QWbmAoR/Hk2gLDVDaYkZJJIntNHT9aiGsJ+YqfZkiot2wtsvB2HCoIfT1Yv2OPKTOyYMCjL8Il5NJ7tVVV5eHq5fvw4vLy8EBQXB0tIShw8fVr+fkJCA27dvIzg4WKv1av217ujRozh58iSaNGmintekSROsWbMGXbt2rfR6YmNjkZ6ejnbtHh5nUSqVOHbsGNauXQuFQqFxw5masntTHUxdmYyrF2yRcN4WA8dlQGqrwsGdLjW+bWYy7kztX8rG96u94VZXAZ/Ghbjxty32bfLCC8MyAAC2Dko0f16ObYt9YSVVwa2eApdOOeLod24Im3dLLxkB8fcTM9WeTIUFFrh1TbNsFBWaQ55tiVvXDP8yNIlQNumyvDamTp2Kfv36wc/PDykpKZg3bx7Mzc0xfPhwyGQyjBkzBlOmTIGLiwscHR3x7rvvIjg4GM8//7xW29G6kPv4+Dzxxi9KpRLe3t6VXs+LL76IixcvaswbNWoUmjZtihkzZuiliAPA0R+dIXNV4s1pqXB2K0XSJRt8OCIA2ZmWetk+MxlvprGLbuDrT3yw6YMAyDMt4exZjJdeT8OQSXfVbSavT8SOJT5Y9W5D5GVboE49BYbPuI3QN7S/6UNVib2fmKl2ZTJq1XSMvLLKD0Xfv38fbm5u6NKlC06dOgU3NzcAwIoVK2BmZobBgwdDoVAgNDQU69ev1zqWRBC0G+T74Ycf8PHHH2PdunVo3749gLIT3959913MmDGj0s8uf5IePXqgTZs2WLlyZaXay+VyyGQy9EB/WEj4i026+/6Odtdv6sPgetp9Oyf6N+ZOMrEjaCgVinE4eztycnJ0Plz6NOW1wmflQpjZVO5Q7pOoCouQPGlujWatikr1yJ2dnSF55EBffn4+OnbsCAuLssVLS0thYWGB0aNH61TIiYiIaoyux7kN9HnklSrkle0h6+rIkSN62Q4REZkgPQ+t60ulCnlYWFhN5yAiIqIq0OlixKKiIhQXF2vMM6TjBkRERGq1tEeu9XXk+fn5mDBhAtzd3WFnZwdnZ2eNiYiIyCDxeeRlpk+fjt9//x0bNmyAtbU1vvjiCyxYsADe3t7Ytm1bTWQkIiKip9B6aH3fvn3Ytm0bevTogVGjRqFr165o2LAh/Pz8sGPHDowYMaImchIREemmlp61rnWP/MGDB6hfvz6AsuPhDx6UPRe3S5cuOHbsWPWmIyIiqibld3bTZTJEWhfy+vXr48aNGwDKnp26a9cuAGU99ccfx0ZEREQ1S+tCPmrUKFy4cAEAMHPmTKxbtw5SqRSTJ0/GtGnTqj0gERFRtailJ7tpfYx88uTJ6v8PCQnBlStXEBsbi4YNG6JVq1bVGo6IiIj+nc4PtfXz84Ofn191ZCEiIqoxEuj49LNqS1K9KlXIV69eXekVvvfee1UOQ0RERNqpVCFfsWJFpVYmkUhYyMmoGeKTxgzyiWy+ncWOUJFKKXYCo6AqLBI7ggaVUPGx2DWmll5+VqlCXn6WOhERkdHiLVqJiIjI0Oh8shsREZFRqKU9chZyIiIyCbrena3W3NmNiIiIDAd75EREZBpq6dB6lXrkx48fx+uvv47g4GDcvXsXALB9+3acOHGiWsMRERFVm1p6i1atC/n333+P0NBQ2NjY4Pz581AoFACAnJwcfPzxx9UekIiIiJ5O60L+0UcfYePGjfj8889haWmpnt+5c2ecO3euWsMRERFVl9r6GFOtj5EnJCSgW7duFebLZDJkZ2dXRyYiIqLqV0vv7KZ1j9zT0xPXrl2rMP/EiROoX79+tYQiIiKqdjxGXmbcuHGYOHEiTp8+DYlEgpSUFOzYsQNTp07F22+/XRMZiYiI6Cm0HlqfOXMmVCoVXnzxRRQUFKBbt26wtrbG1KlT8e6779ZExhrXb2QmXnk7HS5upUiKt8H62XWREGfLTMxkdJmUSmDX8no4trsOstOt4OxZjJ5DMvDKxLuQ/DMqWJhvhq8+9sWZA87Iy7KEu28R/js6FaFvpOslIwC06JiLIW+loVHLQrh6lmD+mPqIPuCkt+0/DX+f/t2wt1PQOTQL9RoUorjIDPHn7PHlUh/cSbIRJY+2eEOYf0gkEnz44Yd48OAB/v77b5w6dQoZGRlYtGhRTeSrcd1fzsL4eSnYsdwT4aGNkRQvxeKoJMhc9fhEHmZipmqyd703DmzzwNiPbmLVkQt4Y9Zt7N3gjV++9FS32bLAD3FHnDBx9XWsOnIBfcak4ovZAYg56KyXjAAgtVUhKd4Wa2f76G2bzyL2Z2cMmVp2zMW+7e6YPCgQs95sCgsLAYu3JcDaxkiePMehdU1WVlYIDAzEc889B3t7+yqtY/78+ZBIJBpT06ZNqxqpSgaNz8T+KBcc/MYFtxOlWD2jHhSFEoQOf6DXHMzETNUh4awDOvTKQtCL2XD3USC47wO07paNa3F2D9vEOqDHkAy06CSHu48CvV5Ph39gPhIfaVPTzv4hw9ZPvHFyv5PetvksYn92xpBp9sgmOPS9G24l2uLGZVt8Oq0+POoWo1HLfFHyUBmth9Z79uwJieTpZ+79/vvvWq2vefPm+O233x4GstDfzeYsLFVo1KoAO9e6q+cJggTnjzsgMKhAbzmYiZmqS5P2uTi0wwMpSVJ41y/CzXhbXIlxwMi5tx62CcpFzCFnvDAsHS6eJfj7pCNSkmwwct6tf1lz7WYIn50xZHqcrUNZTzw320huEqrrJWS1pUfepk0btG7dWj0FBgaiuLgY586dQ8uWLbUOYGFhAU9PT/VUp06dp7ZVKBSQy+Uaky4cXZQwtwCyMzR/CbMyLeDsVqrTupmJmcTINDA8BZ1fzsR73VtjqP9zmBraEn3HpqLboPvqNmMX3YRPo0KM7xCEYQHP4aM3mmLc4hto/nyuXjIaIkP47Iwh06MkEgFvzbmFSzH2uHVV3PMIKk3EofUlS5ZAIpFg0qRJ6nlFRUUIDw+Hq6sr7O3tMXjwYKSlpWm9bq2/Rq1YseKJ8+fPn4+8vDytAyQmJsLb2xtSqRTBwcGIiIiAr6/vE9tGRERgwYIFWm+DyFSc3OeK43vqYNLaa/BpXIAbl+wQOd8Pzh7F6DkkEwDwS6Qnrp6zx8zIK3CrW4z40w74/MMAOHsUo3VX3b4ck+kIX3gL/k0K8f6QQLGjGLyYmBh89tlnaNWqlcb8yZMn4+eff8a3334LmUyGCRMmYNCgQfjzzz+1Wn+1Pf3s9ddfx5dffqnVMh07dsSWLVuwf/9+bNiwATdu3EDXrl2Rm/vknsGsWbOQk5OjnpKTk3XKLH9gDmUp4PTYt1vnOqXIyhBnqIiZmEkX2z7yxcDwFHTpfx9+zQrR45VM9BuXit1r6wIAFIUSRC31wch5t9DhpWz4Bxbgv6PS0Lnfffy40VsvGQ2RIXx2xpCp3DsLbqLjC9mYPrwZMlOtRM2ilWrqkT8+Mlx+q/InycvLw4gRI/D555/D2fnhCaU5OTnYvHkzli9fjhdeeAFBQUGIjIzEyZMncerUKa1+rGor5NHR0ZBKpVot07t3bwwZMgStWrVCaGgofvnlF2RnZ2PXrl1PbG9tbQ1HR0eNSRelJWZI/MsWbbs8/OIgkQho0yUP8bHiDBUxEzPpQlFoBslj/6rNzAUIqrL/V5aaobTEDI+f5mJmLkAw0ON/+mAIn50xZAIEvLPgJjr1ysKMEU2RdsdapBxVU123aPXx8YFMJlNPERERT91meHg4+vTpg5CQEI35sbGxKCkp0ZjftGlT+Pr6Ijo6WqufS+uvdYMGDdJ4LQgC7t27h7Nnz2LOnDnark6Dk5MTGjdu/MQ7x9WU3ZvqYOrKZFy9YIuE87YYOC4DUlsVDu500VsGZmKm6tL+pWx8v9obbnUV8GlciBt/22LfJi+8MCwDQNnJSc2fl2PbYl9YSVVwq6fApVOOOPqdG8L0eLKb1FYJb/+HvRhPHwXqBxYgN9sCGSni9PDE/uyMIVP4wlvo2f8+FoxvhMI8MzjXKQYA5OdaoFhRbf1Cg5ecnKzRkbS2fvIXmp07d+LcuXOIiYmp8F5qaiqsrKzg5OSkMd/DwwOpqala5dG6kMtkMo3XZmZmaNKkCRYuXIhevXppuzoNeXl5uH79Ot544w2d1qONoz86Q+aqxJvTUuHsVoqkSzb4cEQAsjMtn70wMzGTgWUau+gGvv7EB5s+CIA80xLOnsV46fU0DJl0V91m8vpE7Fjig1XvNkRetgXq1FNg+IzbCH1D+5Nsqqpx6wJ88m2i+vVb88vyHdzlgk+n+Ostx6PE/uyMIVO/f24a9MnOKxrzP50agEPfu4kRSRSVGRFOTk7GxIkTcejQIa1Hq7UlEYTKD6gplUr8+eefaNmypcZYf1VNnToV/fr1g5+fH1JSUjBv3jzExcUhPj4ebm7P/qWQy+WQyWTogf6wkIj3j42oJn1/R7vjZfow2Lez2BEqUhnJTUlEJnlK71EspUIJ/lDsQk5Ojs6HS5+mvFY0mPUxzHUoqsqiIlyP+KBSWffu3YuBAwfC3Nz84fJKJSQSCczMzHDgwAGEhIQgKytLo1fu5+eHSZMmYfLkyZXOpVWP3NzcHL169cLly5erpZDfuXMHw4cPx/379+Hm5oYuXbrg1KlTlSriRERE2tDnLVpffPFFXLx4UWPeqFGj0LRpU8yYMQM+Pj6wtLTE4cOHMXjwYABlTxe9ffs2goODtcql9dB6ixYtkJSUhICAAG0XrWDnzp06r4OIiMjQODg4oEWLFhrz7Ozs4Orqqp4/ZswYTJkyBS4uLnB0dMS7776L4OBgPP/881ptS+tC/tFHH2Hq1KlYtGgRgoKCYGeneVvHmhoaISIi0pkBXZ2xYsUKmJmZYfDgwVAoFAgNDcX69eu1Xk+lC/nChQvx/vvv47///S8A4OWXX9a4VasgCJBIJFAqeZyKiIgMkK4PPtHxS8CRI0c0XkulUqxbtw7r1q3Tab2VLuQLFizAW2+9hT/++EOnDRIREVH1qXQhLz+5vXv37jUWhoiIqKbU1ueRa3WM/N+eekZERGTQRB5arylaFfLGjRs/s5g/eCDes3uJiIhMjVaFfMGCBRXu7EZERGQMOLQO4NVXX4W7u/uzGxIRERmaWjq0Xum73PP4OBERkeHR+qx1IiIio1RLe+SVLuQqlaomcxAREdUoHiOnyjMzf3YbfeOToYzW4Hra3XdZHw6kxIodoYJQ7zZiRzAKgkLx7EZ6JAgletwYamWP3HSeBE9ERFQLsUdORESmoZb2yFnIiYjIJNTWY+QcWiciIjJi7JETEZFp4NA6ERGR8eLQOhERERkc9siJiMg0cGidiIjIiNXSQs6hdSIiIiPGHjkREZkEyT+TLssbIhZyIiIyDRxar736jczE1tPx2Jf0F1b9lIgmbQpEzdOiYy4WRF5D1NmLOHDnHIJDs0XNU87Q9hMzGUemgjwzbJhbF290CES/+q0wqV8jJMTZqN8XBGDrMk8Mb9Mc/eq3woyhDXA3yUpv+R7Fz854M1VG+eVnukyGyOQLefeXszB+Xgp2LPdEeGhjJMVLsTgqCTJXPT6R5zFSWxWS4m2xdraPaBkeZ4j7iZmMI9OK931w7pg9pq+5hY2HryCoey5mDmuIzHuWAIBd69zxw5dueHdJMlb9dBVSWxU+eK0Biov0O5Ap9n5iJqoq0Qv53bt38frrr8PV1RU2NjZo2bIlzp49q7ftDxqfif1RLjj4jQtuJ0qxekY9KAolCB3+QG8ZHnf2Dxm2fuKNk/udRMvwOEPcT8xk+JkUhRKc+MUJY2ffQ8vn81E3oBhvTE2Ft78CP21zhSAAe79ww/CJqej0HznqBxZh+upbuJ9miZP7ZTWe71H87Iw3U6UJ1TAZIFELeVZWFjp37gxLS0v8+uuviI+Px6effgpnZ2e9bN/CUoVGrQpw7riDep4gSHD+uAMCg4xjqEgfDHE/MZNxZFIqJVApJbCyVmnMt5aqcOmMPVJvW+FBuiXadc1Tv2fnqELTtgW4HGtX4/nKib2fmEmPalkRB0Q+2W3p0qXw8fFBZGSkel5AQMBT2ysUCigUCvVruVyu0/YdXZQwtwCyMzR3Q1amBXwaKp6ylOkxxP3ETMaRydZehWZB+Yha6QnfRjfh5FaKI3udcTnWDt7+CjxIL8vl5KY5LOvkVqJ+Tx/E3k/MRLoQtUf+448/on379hgyZAjc3d3Rtm1bfP75509tHxERAZlMpp58fAznGDIRPdn0NbcgCMBr7Vqgr39r7N1cBz0GZEEi+oE9MjU82a0GJCUlYcOGDWjUqBEOHDiAt99+G++99x62bt36xPazZs1CTk6OekpOTtZp+/IH5lCWAk5upRrzneuUIiuDV+aVM8T9xEzGk8nbvxj/t/safrj2F746ewlrfklEaYkEXn4KuLiX5crOsNRYJjvDUv2ePhjCfmImPeAx8uqnUqnQrl07fPzxx2jbti3Gjx+PcePGYePGjU9sb21tDUdHR41JF6UlZkj8yxZtu+Sq50kkAtp0yUN8rK1O665NDHE/MZPxZZLaquDqUYrcbHPEHnVEcKgcnr7FcHEvwfkT9up2+blmuHLeFs2C8vWWzZD2EzORtkQt5F5eXggMDNSY16xZM9y+fVtvGXZvqoPerz1AyJAH8GlYhHeX3IHUVoWDO130luFxUlsl6gcWoH5g2ckjnj4K1A8sgJt3sWiZDHE/MZNxZDp7xAExfzgg9bYVYo/aY/orDeHTsAi9ht2HRAIMGJuBr1d5IPqAI25cluKT9/zg6lGCTv/J0Uu+cmLvJ2aqefoeWt+wYQNatWql7ngGBwfj119/Vb9fVFSE8PBwuLq6wt7eHoMHD0ZaWprWP5eoYyGdO3dGQkKCxryrV6/Cz89PbxmO/ugMmasSb05LhbNbKZIu2eDDEQHIzrR89sI1pHHrAnzybaL69Vvz7wIADu5ywadT/EXJZIj7iZmMI1O+3ByREV7IvGcJByclOv83G6Nm3oPFP5sfGp6OogIzrJrugzy5OZp3yMfiHUmwkup3HFPs/cRMeqDnO7vVq1cPS5YsQaNGjSAIArZu3Yr+/fvj/PnzaN68OSZPnoyff/4Z3377LWQyGSZMmIBBgwbhzz//1Go7EkEQRBv1j4mJQadOnbBgwQIMHToUZ86cwbhx47Bp0yaMGDHimcvL5XLIZDL0QH9YSAzol8jMXOwEFamUYiegWuRASpzYESoI9W4jdgSqglKhBEfwA3JycnQ+XPo05bWi5ZiPYW4lrfJ6lMVFuLj5A52yuri44JNPPsErr7wCNzc3REVF4ZVXXgEAXLlyBc2aNUN0dDSef/75Sq9T1KH1Dh06YM+ePfj666/RokULLFq0CCtXrqxUESciItJGdQ2ty+VyjenRy6KfRqlUYufOncjPz0dwcDBiY2NRUlKCkJAQdZumTZvC19cX0dHRWv1cop9m2LdvX/Tt21fsGEREVNtV09D645c+z5s3D/Pnz3/iIhcvXkRwcDCKiopgb2+PPXv2IDAwEHFxcbCysoKTk5NGew8PD6SmpmoVS/RCTkREpBfVVMiTk5M1htatra2fukiTJk0QFxeHnJwcfPfddwgLC8PRo0d1CFERCzkREZEWtLn82crKCg0bNgQABAUFISYmBqtWrcKwYcNQXFyM7OxsjV55WloaPD09tcrDeysREZFJMIQ7u6lUKigUCgQFBcHS0hKHDx9Wv5eQkIDbt28jODhYq3WyR05ERKZBz5efzZo1C71794avry9yc3MRFRWFI0eO4MCBA5DJZBgzZgymTJkCFxcXODo64t1330VwcLBWZ6wDLOREREQ1Ij09HW+++Sbu3bsHmUyGVq1a4cCBA3jppZcAACtWrICZmRkGDx4MhUKB0NBQrF+/XuvtsJATEZFJkAgCJDrcOkXbZTdv3vyv70ulUqxbtw7r1q2rciaAhZyIiEyFnofW9YUnuxERERkx9siJiMgk6HrmuaE+j5yFnIiITAOH1omIiMjQsEdeE/ikMapOBvg0PUN80tj3d06JHaGCwfW0ux6YahaH1omIiIxZLR1aZyEnIiKTUFt75DxGTkREZMTYIyciItPAoXUiIiLjZqjD47rg0DoREZERY4+ciIhMgyCUTbosb4BYyImIyCTwrHUiIiIyOOyRExGRaeBZ60RERMZLoiqbdFneEHFonYiIyIixRw6g38hMvPJ2OlzcSpEUb4P1s+siIc6WmZipVmRq0TEXQ95KQ6OWhXD1LMH8MfURfcBJtDzlxNpPSiWwa3k9HNtdB9npVnD2LEbPIRl4ZeJdSCRlbQrzzfDVx744c8AZeVmWcPctwn9HpyL0jfQaz/c4Q/t9MtRMlVJLh9ZNvkfe/eUsjJ+Xgh3LPREe2hhJ8VIsjkqCzLWEmZipVmSS2qqQFG+LtbN9RMvwODH309713jiwzQNjP7qJVUcu4I1Zt7F3gzd++dJT3WbLAj/EHXHCxNXXserIBfQZk4ovZgcg5qBzjed7lCH+PhlipsoqP2tdl8kQiVrI/f39IZFIKkzh4eF6yzBofCb2R7ng4DcuuJ0oxeoZ9aAolCB0+AO9ZWAmZqpJZ/+QYesn3ji530m0DI8Tcz8lnHVAh15ZCHoxG+4+CgT3fYDW3bJxLc7uYZtYB/QYkoEWneRw91Gg1+vp8A/MR+IjbfTBEH+fDDFTpZVfR67LZIBELeQxMTG4d++eejp06BAAYMiQIXrZvoWlCo1aFeDccQf1PEGQ4PxxBwQGFeglAzMxk6kRez81aZ+Li3/KkJIkBQDcjLfFlRgHtO2Z/bBNUC5iDjnj/j1LCAJw8U9HpCTZoHW3nBrPV07s/WQsmUjkY+Rubm4ar5csWYIGDRqge/fuT2yvUCigUCjUr+VyuU7bd3RRwtwCyM7Q3A1ZmRbwaah4ylI1i5mYqbYTez8NDE9BQa453uveGmbmAlRKCV6bkYxug+6r24xddBMbZ9TH+A5BMLdQQWIGvL0sCc2fz63xfOXE3k/GkkkbtfWGMAZzsltxcTG++uorTJkyBZLyM04eExERgQULFug5GRHVJif3ueL4njqYtPYafBoX4MYlO0TO94OzRzF6DskEAPwS6Ymr5+wxM/IK3OoWI/60Az7/MADOHsVo3VW3DgSJqJae7GYwhXzv3r3Izs7GyJEjn9pm1qxZmDJlivq1XC6Hj0/VT+CRPzCHshRwcivVmO9cpxRZGeLsGmZiptpO7P207SNfDAxPQZf+ZT1wv2aFyLxrjd1r66LnkEwoCiWIWuqD6V9cRdCL2QAA/8AC3Lxkhx83euutkIu9n4wlExnQWeubN29G79694e3t/dQ21tbWcHR01Jh0UVpihsS/bNG2y8PhMolEQJsueYiPFedSCmZiptpO7P2kKDSD5LG/fGbmAoR/bvahLDVDaYkZHh8YNDMX9Hquk9j7yVgyaaO2nrVuEF+hbt26hd9++w27d+/W+7Z3b6qDqSuTcfWCLRLO22LguAxIbVU4uNNF71mYiZlqgtRWCW//h8cvPX0UqB9YgNxsC2SkWImSScz91P6lbHy/2htudRXwaVyIG3/bYt8mL7wwLAMAYOugRPPn5di22BdWUhXc6ilw6ZQjjn7nhrB5t2o836MM8ffJEDNVGp9+VnMiIyPh7u6OPn366H3bR390hsxViTenpcLZrRRJl2zw4YgAZGda6j0LMzFTTWjcugCffJuofv3W/LsAgIO7XPDpFH9RMom5n8YuuoGvP/HBpg8CIM+0hLNnMV56PQ1DJt1Vt5m8PhE7lvhg1bsNkZdtgTr1FBg+4zZC30ir8XyPMsTfJ0PMZOokgiDuVwyVSoWAgAAMHz4cS5Ys0WpZuVwOmUyGHugPCwl/iaiWMjMXO0FFKqXYCSr4/s4psSNUMLje82JHMHilQgmO4Afk5OTofLj0acprRXDvhbCwlFZ5PaUlRYj+dW6NZq0K0Xvkv/32G27fvo3Ro0eLHYWIiGqzWnrWuugnu/Xq1QuCIKBx48ZiRyEiIqo2ERER6NChAxwcHODu7o4BAwYgISFBo01RURHCw8Ph6uoKe3t7DB48GGlp2h3CEb2QExER6YO+z1o/evQowsPDcerUKRw6dAglJSXo1asX8vPz1W0mT56Mffv24dtvv8XRo0eRkpKCQYMGabUd0YfWiYiI9EIllE26LK+F/fv3a7zesmUL3N3dERsbi27duiEnJwebN29GVFQUXnjhBQBlJ383a9YMp06dwvPPV+4cC/bIiYjINAjVMKHs5LlHp0dvHf5vcnLK7tXv4lJ2qV5sbCxKSkoQEhKibtO0aVP4+voiOjq60j8WCzkREZEWfHx8IJPJ1FNERMQzl1GpVJg0aRI6d+6MFi1aAABSU1NhZWUFJycnjbYeHh5ITU2tdB4OrRMRkUmQQMeHpvzz3+TkZI3Lz6ytrZ+5bHh4OP7++2+cOHGi6gGegoWciIhMQzXd2U3bW4RPmDABP/30E44dO4Z69eqp53t6eqK4uBjZ2dkavfK0tDR4enpWev0cWiciIqoBgiBgwoQJ2LNnD37//XcEBARovB8UFARLS0scPnxYPS8hIQG3b99GcHBwpbfDHjkREZkEfT+PPDw8HFFRUfjhhx/g4OCgPu4tk8lgY2MDmUyGMWPGYMqUKXBxcYGjoyPeffddBAcHV/qMdYCFnIiITIWe7+y2YcMGAECPHj005kdGRqof2b1ixQqYmZlh8ODBUCgUCA0Nxfr167XaDgs5ERFRDajMo0ykUinWrVuHdevWVXk7LORERGQSJIIAiQ4nu+mybE1iIScydAb4pDFDZIhPGuMT2QyM6p9Jl+UNEM9aJyIiMmLskRMRkUng0DoREZExq6XPI2chJyIi01BNd3YzNDxGTkREZMTYIyciIpOg7zu76QsLORERmQYOrRMREZGhYY+ciIhMgkRVNumyvCFiISciItPAoXUiIiIyNOyRExGRaeANYWqvfiMz8crb6XBxK0VSvA3Wz66LhDhbZmImZmImvWRSKoFdy+vh2O46yE63grNnMXoOycArE+9CIilrU5hvhq8+9sWZA87Iy7KEu28R/js6FaFvpNd4vscZ4mdXGbX1Fq0mP7Te/eUsjJ+Xgh3LPREe2hhJ8VIsjkqCzLWEmZiJmZhJL5n2rvfGgW0eGPvRTaw6cgFvzLqNvRu88cuXnuo2Wxb4Ie6IEyauvo5VRy6gz5hUfDE7ADEHnWs836MM8bMzdaIWcqVSiTlz5iAgIAA2NjZo0KABFi1aVKmHsVeXQeMzsT/KBQe/ccHtRClWz6gHRaEEocMf6C0DMzETM5l2poSzDujQKwtBL2bD3UeB4L4P0LpbNq7F2T1sE+uAHkMy0KKTHO4+CvR6PR3+gflIfKSNPhjiZ1dp5Se76TIZIFEL+dKlS7FhwwasXbsWly9fxtKlS7Fs2TKsWbNGL9u3sFShUasCnDvuoJ4nCBKcP+6AwKACvWRgJmZiJmZq0j4XF/+UISVJCgC4GW+LKzEOaNsz+2GboFzEHHLG/XuWEATg4p+OSEmyQetuOTWer5zY+0lnAh4+k7wqk2HWcXGPkZ88eRL9+/dHnz59AAD+/v74+uuvcebMmSe2VygUUCgU6tdyuVyn7Tu6KGFuAWRnaO6GrEwL+DRUPGWpmsVMzMRMppdpYHgKCnLN8V731jAzF6BSSvDajGR0G3Rf3WbsopvYOKM+xncIgrmFChIz4O1lSWj+fG6N5ysn9n7SVW09Ri5qIe/UqRM2bdqEq1evonHjxrhw4QJOnDiB5cuXP7F9REQEFixYoOeUREQ16+Q+VxzfUweT1l6DT+MC3Lhkh8j5fnD2KEbPIZkAgF8iPXH1nD1mRl6BW91ixJ92wOcfBsDZoxitu+rWqSHjJmohnzlzJuRyOZo2bQpzc3MolUosXrwYI0aMeGL7WbNmYcqUKerXcrkcPj4+Vd6+/IE5lKWAk1upxnznOqXIyhBn1zATMzGT6WXa9pEvBoanoEv/sh64X7NCZN61xu61ddFzSCYUhRJELfXB9C+uIujFbACAf2ABbl6yw48bvfVWyMXeTzoToOMNYaotSbUS9Rj5rl27sGPHDkRFReHcuXPYunUr/u///g9bt259Yntra2s4OjpqTLooLTFD4l+2aNvl4dCURCKgTZc8xMeKcykFMzETM5leJkWhGSSP/TU2Mxcg/HNLUGWpGUpLzNSXomm00WNxEXs/6ayWnuwm6leoadOmYebMmXj11VcBAC1btsStW7cQERGBsLAwvWTYvakOpq5MxtULtkg4b4uB4zIgtVXh4E4XvWyfmZiJmZip/UvZ+H61N9zqKuDTuBA3/rbFvk1eeGFYBgDA1kGJ5s/LsW2xL6ykKrjVU+DSKUcc/c4NYfNu1Xi+RxniZ2fqRC3kBQUFMDPT/Bpqbm4OlUp/d6Y/+qMzZK5KvDktFc5upUi6ZIMPRwQgO9NSbxmYiZmYybQzjV10A19/4oNNHwRAnmkJZ89ivPR6GoZMuqtuM3l9InYs8cGqdxsiL9sCdeopMHzGbYS+kVbj+R5liJ9dpakASJ7Z6t+XN0ASQZ8XbT9m5MiR+O233/DZZ5+hefPmOH/+PMaPH4/Ro0dj6dKlz1xeLpdDJpOhB/rDQmIEv0REZFK+v3NK7AgVDK73vNgRNJQKJTiCH5CTk6Pz4dKnKa8VL7aYDgtz6yqvp1SpwOG/l9Vo1qoQtUe+Zs0azJkzB++88w7S09Ph7e2N//3vf5g7d66YsYiIiIyGqIXcwcEBK1euxMqVK8WMQUREpqCWPsbUCK4XICIiqga1tJCb/ENTiIiIjBl75EREZBrYIyciIjJiujwwpXzSwrFjx9CvXz94e3tDIpFg7969Gu8LgoC5c+fCy8sLNjY2CAkJQWJiotY/Fgs5ERGZhPKHpugyaSM/Px+tW7fGunXrnvj+smXLsHr1amzcuBGnT5+GnZ0dQkNDUVRUpNV2OLRORERUA3r37o3evXs/8T1BELBy5UrMnj0b/fv3BwBs27YNHh4e2Lt3r/qOp5XBHjkREZmGarrXulwu15gefbx2Zd24cQOpqakICQlRz5PJZOjYsSOio6O1WhcLORERmQaVoPsEwMfHBzKZTD1FRERoHSU1NRUA4OHhoTHfw8ND/V5lcWidiIhIC8nJyRq3aLW2rvptX6sDe+RERGQaqmlo/fHHaVelkHt6egIA0tI0H3qTlpamfq+yWMiJiMhE6FrEq+868oCAAHh6euLw4cPqeXK5HKdPn0ZwcLBW6+LQOonHzFzsBBWplGInqIj7yWgZ2pPGAOBASpzYETTIc1Vwbix2ipqRl5eHa9euqV/fuHEDcXFxcHFxga+vLyZNmoSPPvoIjRo1QkBAAObMmQNvb28MGDBAq+2wkBMRkWnQ853dzp49i549e6pfT5kyBQAQFhaGLVu2YPr06cjPz8f48eORnZ2NLl26YP/+/ZBKpVpth4WciIhMg0rH4XGVdsv26NEDwr8Uf4lEgoULF2LhwoVVzwQeIyciIjJq7JETEZFpEFRlky7LGyAWciIiMg219OlnLORERGQa9HyMXF94jJyIiMiIsUdORESmgUPrRERERkyAjoW82pJUKw6tExERGTH2yImIyDRwaJ2IiMiIqVQAdLgWXGWY15FzaB1Av5GZ2Ho6HvuS/sKqnxLRpE2B2JGYqRJadMzFgshriDp7EQfunENwaLaoecpxP1WOoe0nZqqoIM8MG+bWxRsdAtGvfitM6tcICXE26vcFAdi6zBPD2zRHv/qtMGNoA9xNstJbPipj8oW8+8tZGD8vBTuWeyI8tDGS4qVYHJUEmWsJMxl4JqmtCknxtlg720e0DI/jfqocQ9xPzFTRivd9cO6YPaavuYWNh68gqHsuZg5riMx7lgCAXevc8cOXbnh3STJW/XQVUlsVPnitAYqLJHrJp7Vqeh65oRG1kOfm5mLSpEnw8/ODjY0NOnXqhJiYGL1mGDQ+E/ujXHDwGxfcTpRi9Yx6UBRKEDr8gV5zMJP2zv4hw9ZPvHFyv5NoGR7H/VQ5hrifmEmTolCCE784Yezse2j5fD7qBhTjjamp8PZX4KdtrhAEYO8Xbhg+MRWd/iNH/cAiTF99C/fTLHFyv6zG81UJC3n1Gzt2LA4dOoTt27fj4sWL6NWrF0JCQnD37l29bN/CUoVGrQpw7riDep4gSHD+uAMCg8QZUmMm48X9VDmGuJ+YqSKlUgKVUgIra83jwtZSFS6dsUfqbSs8SLdEu6556vfsHFVo2rYAl2PtajwfPSRaIS8sLMT333+PZcuWoVu3bmjYsCHmz5+Phg0bYsOGDU9cRqFQQC6Xa0y6cHRRwtwCyM7QPOcvK9MCzm6lOq2bmUwP91PlGOJ+YqaKbO1VaBaUj6iVnrifagGlEjj8vTMux9rhQZoFHqSX5XJy0xzmd3IrUb9ncFSC7pMBEq2Ql5aWQqlUVniAuo2NDU6cOPHEZSIiIiCTydSTj4/hHPMjIqptpq+5BUEAXmvXAn39W2Pv5jroMSALEiM9u0oQVDpPhki0j8PBwQHBwcFYtGgRUlJSoFQq8dVXXyE6Ohr37t174jKzZs1CTk6OekpOTtYpg/yBOZSlgNNj326d65QiK0Ocb5TMZLy4nyrHEPcTMz2Zt38x/m/3Nfxw7S98dfYS1vySiNISCbz8FHBxL8uVnWGpsUx2hqX6PYMj6Ngb5zHyirZv3w5BEFC3bl1YW1tj9erVGD58OMzMnhzL2toajo6OGpMuSkvMkPiXLdp2yVXPk0gEtOmSh/hYW53WzUymh/upcgxxPzHTv5PaquDqUYrcbHPEHnVEcKgcnr7FcHEvwfkT9up2+blmuHLeFs2C8vWaz9SJ2k1o0KABjh49ivz8fMjlcnh5eWHYsGGoX7++3jLs3lQHU1cm4+oFWySct8XAcRmQ2qpwcKeL3jIwU9VIbZXw9leoX3v6KFA/sAC52RbISBHnWlbup8oxxP3ETBWdPeIAQQB8Gihw94YVvlhUFz4Ni9Br2H1IJMCAsRn4epUH6gYo4OlbjK3LvODqUYJO/8nRSz6tCTo+xtRAe+QGMd5nZ2cHOzs7ZGVl4cCBA1i2bJnetn30R2fIXJV4c1oqnN1KkXTJBh+OCEB2puWzF2YmUTM1bl2AT75NVL9+a37Z1Q4Hd7ng0yn+omTifqocQ9xPzFRRvtwckRFeyLxnCQcnJTr/NxujZt6DxT+bHxqejqICM6ya7oM8uTmad8jH4h1JsJIaZsGDSgVIdDjObaDHyCWCIN5XjAMHDkAQBDRp0gTXrl3DtGnTIJVKcfz4cVhaPvsXVS6XQyaToQf6w0Ii3j82qiIzc7ETVKRSip2gIu4nqkYHUuLEjqBBnquCc+Mk5OTk6Hy49Knb+KdWvOgwAhaSqo9ClQrFOJy7o0azVoWoPfKcnBzMmjULd+7cgYuLCwYPHozFixdXqogTERFphUPr1W/o0KEYOnSomBGIiMhECCoVBB2G1nn5GREREVU7gzjZjYiIqMZxaJ2IiMiIqQRAUvsKOYfWiYiIjBh75EREZBoEAYAu15EbZo+chZyIiEyCoBIg6DC0LuJtV/4VCzkREZkGQQXdeuS8/IyIiMjkrFu3Dv7+/pBKpejYsSPOnDlTretnISciIpMgqASdJ2198803mDJlCubNm4dz586hdevWCA0NRXp6erX9XCzkRERkGgSV7pOWli9fjnHjxmHUqFEIDAzExo0bYWtriy+//LLafiyjPkZefuJBKUp0usafRGKIx5sEA3wYCPcTVSN5rmH9PsnzyvLo40QyXWtFKUoAlD2E5VHW1tawtrau0L64uBixsbGYNWuWep6ZmRlCQkIQHR1d9SCPMepCnpubCwA4gV9ETkJVYlh/TwwX9xNVI+fGYid4stzcXMhkshpZt5WVFTw9PXEiVfdaYW9vDx8fH4158+bNw/z58yu0zczMhFKphIeHh8Z8Dw8PXLlyRecs5Yy6kHt7eyM5ORkODg6QSCQ6rUsul8PHxwfJyckG83g6ZqocQ8tkaHkAZqosZqqc6swkCAJyc3Ph7e1dTekqkkqluHHjBoqLi3VelyAIFerNk3rj+mTUhdzMzAz16tWr1nU6OjoazD+WcsxUOYaWydDyAMxUWcxUOdWVqaZ64o+SSqWQSqU1vp1H1alTB+bm5khLS9OYn5aWBk9Pz2rbDk92IyIiqgFWVlYICgrC4cOH1fNUKhUOHz6M4ODgatuOUffIiYiIDNmUKVMQFhaG9u3b47nnnsPKlSuRn5+PUaNGVds2WMj/YW1tjXnz5ol+rONRzFQ5hpbJ0PIAzFRZzFQ5hpjJUA0bNgwZGRmYO3cuUlNT0aZNG+zfv7/CCXC6kAiGevNYIiIieiYeIyciIjJiLORERERGjIWciIjIiLGQExERGTEWctT8I+a0dezYMfTr1w/e3t6QSCTYu3evqHkiIiLQoUMHODg4wN3dHQMGDEBCQoKomTZs2IBWrVqpb0gRHByMX3/9VdRMj1uyZAkkEgkmTZokWob58+dDIpFoTE2bNhUtT7m7d+/i9ddfh6urK2xsbNCyZUucPXtWtDz+/v4V9pNEIkF4eLhomZRKJebMmYOAgADY2NigQYMGWLRokV7uSf5vcnNzMWnSJPj5+cHGxgadOnVCTEyMqJlMnckXcn08Yk5b+fn5aN26NdatWydahkcdPXoU4eHhOHXqFA4dOoSSkhL06tUL+fn5omWqV68elixZgtjYWJw9exYvvPAC+vfvj0uXLomW6VExMTH47LPP0KpVK7GjoHnz5rh37556OnHihKh5srKy0LlzZ1haWuLXX39FfHw8Pv30Uzg7O4uWKSYmRmMfHTp0CAAwZMgQ0TItXboUGzZswNq1a3H58mUsXboUy5Ytw5o1a0TLBABjx47FoUOHsH37dly8eBG9evVCSEgI7t69K2oukyaYuOeee04IDw9Xv1YqlYK3t7cQEREhYqqHAAh79uwRO4aG9PR0AYBw9OhRsaNocHZ2Fr744guxYwi5ublCo0aNhEOHDgndu3cXJk6cKFqWefPmCa1btxZt+08yY8YMoUuXLmLH+FcTJ04UGjRoIKhUKtEy9OnTRxg9erTGvEGDBgkjRowQKZEgFBQUCObm5sJPP/2kMb9du3bChx9+KFIqMukeefkj5kJCQtTzauIRc7VNTk4OAMDFxUXkJGWUSiV27tyJ/Pz8ar3tYVWFh4ejT58+Gr9XYkpMTIS3tzfq16+PESNG4Pbt26Lm+fHHH9G+fXsMGTIE7u7uaNu2LT7//HNRMz2quLgYX331FUaPHq3zw5h00alTJxw+fBhXr14FAFy4cAEnTpxA7969RctUWloKpVJZ4Z7lNjY2oo/0mDKTvrObvh4xV5uoVCpMmjQJnTt3RosWLUTNcvHiRQQHB6OoqAj29vbYs2cPAgMDRc20c+dOnDt3zmCOGXbs2BFbtmxBkyZNcO/ePSxYsABdu3bF33//DQcHB1EyJSUlYcOGDZgyZQo++OADxMTE4L333oOVlRXCwsJEyfSovXv3Ijs7GyNHjhQ1x8yZMyGXy9G0aVOYm5tDqVRi8eLFGDFihGiZHBwcEBwcjEWLFqFZs2bw8PDA119/jejoaDRs2FC0XKbOpAs5aS88PBx///23QXz7btKkCeLi4pCTk4PvvvsOYWFhOHr0qGjFPDk5GRMnTsShQ4f0/pSlp3m099aqVSt07NgRfn5+2LVrF8aMGSNKJpVKhfbt2+Pjjz8GALRt2xZ///03Nm7caBCFfPPmzejdu3eNPlazMnbt2oUdO3YgKioKzZs3R1xcHCZNmgRvb29R99P27dsxevRo1K1bF+bm5mjXrh2GDx+O2NhY0TKZOpMu5Pp6xFxtMWHCBPz00084duxYtT8+tiqsrKzUvYCgoCDExMRg1apV+Oyzz0TJExsbi/T0dLRr1049T6lU4tixY1i7di0UCgXMzc1FyVbOyckJjRs3xrVr10TL4OXlVeHLVrNmzfD999+LlOihW7du4bfffsPu3bvFjoJp06Zh5syZePXVVwEALVu2xK1btxARESFqIW/QoAGOHj2K/Px8yOVyeHl5YdiwYahfv75omUydSR8j19cj5oydIAiYMGEC9uzZg99//x0BAQFiR3oilUoFhUIh2vZffPFFXLx4EXFxceqpffv2GDFiBOLi4kQv4gCQl5eH69evw8vLS7QMnTt3rnD54tWrV+Hn5ydSoociIyPh7u6OPn36iB0FBQUFMDPT/BNtbm4OlUolUiJNdnZ28PLyQlZWFg4cOID+/fuLHclkmXSPHNDPI+a0lZeXp9FjunHjBuLi4uDi4gJfX1+95wkPD0dUVBR++OEHODg4IDU1FQAgk8lgY2Oj9zwAMGvWLPTu3Ru+vr7Izc1FVFQUjhw5ggMHDoiSByg7fvj4eQN2dnZwdXUV7XyCqVOnol+/fvDz80NKSgrmzZsHc3NzDB8+XJQ8ADB58mR06tQJH3/8MYYOHYozZ85g06ZN2LRpk2iZgLIvgpGRkQgLC4OFhfh/Gvv164fFixfD19cXzZs3x/nz57F8+XKMHj1a1FwHDhyAIAho0qQJrl27hmnTpqFp06ai/s00eWKfNm8I1qxZI/j6+gpWVlbCc889J5w6dUrUPH/88YcAoMIUFhYmSp4nZQEgREZGipJHEARh9OjRgp+fn2BlZSW4ubkJL774onDw4EHR8jyN2JefDRs2TPDy8hKsrKyEunXrCsOGDROuXbsmWp5y+/btE1q0aCFYW1sLTZs2FTZt2iR2JOHAgQMCACEhIUHsKIIgCIJcLhcmTpwo+Pr6ClKpVKhfv77w4YcfCgqFQtRc33zzjVC/fn3ByspK8PT0FMLDw4Xs7GxRM5k6PsaUiIjIiJn0MXIiIiJjx0JORERkxFjIiYiIjBgLORERkRFjISciIjJiLORERERGjIWciIjIiLGQExERGTEWciIdjRw5EgMGDFC/7tGjByZNmqT3HEeOHIFEIkF2dvZT20gkEuzdu7fS65w/fz7atGmjU66bN29CIpEgLi5Op/UQ0ZOxkFOtNHLkSEgkEkgkEvVT0hYuXIjS0tIa3/bu3buxaNGiSrWtTPElIvo34j8ZgKiG/Oc//0FkZCQUCgV++eUXhIeHw9LSErNmzarQtri4GFZWVtWyXRcXl2pZDxFRZbBHTrWWtbU1PD094efnh7fffhshISH48ccfATwcDl+8eDG8vb3RpEkTAEBycjKGDh0KJycnuLi4oH///rh586Z6nUqlElOmTIGTkxNcXV0xffp0PP64gseH1hUKBWbMmAEfHx9YW1ujYcOG2Lx5M27evImePXsCAJydnSGRSDBy5EgAZU/iioiIQEBAAGxsbNC6dWt89913Gtv55Zdf0LhxY9jY2KBnz54aOStrxowZaNy4MWxtbVG/fn3MmTMHJSUlFdp99tln8PHxga2tLYYOHYqcnByN97/44gs0a9YMUqkUTZs2xfr167XOQkRVw0JOJsPGxgbFxcXq14cPH0ZCQgIOHTqEn376CSUlJQgNDYWDgwOOHz+OP//8E/b29vjPf/6jXu7TTz/Fli1b8OWXX+LEiRN48OAB9uzZ86/bffPNN/H1119j9erVuHz5Mj777DPY29vDx8cH33//PQAgISEB9+7dw6pVqwAAERER2LZtGzZu3IhLly5h8uTJeP3113H06FEAZV84Bg0ahH79+iEuLg5jx47FzJkztd4nDg4O2LJlC+Lj47Fq1Sp8/vnnWLFihUaba9euYdeuXdi3bx/279+P8+fP45133lG/v2PHDsydOxeLFy/G5cuX8fHHH2POnDnYunWr1nmIqApEfvoaUY0ICwsT+vfvLwiCIKhUKuHQoUOCtbW1MHXqVPX7Hh4eGo+E3L59u9CkSRNBpVKp5ykUCsHGxkY4cOCAIAiC4OXlJSxbtkz9fklJiVCvXj31tgRB89GlCQkJAgDh0KFDT8xZ/sjarKws9byioiLB1tZWOHnypEbbMWPGCMOHDxcEQRBmzZolBAYGarw/Y8aMCut6HABhz549T33/k08+EYKCgtSv582bJ5ibmwt37txRz/v1118FMzMz4d69e4IgCEKDBg2EqKgojfUsWrRICA4OFgRBEG7cuCEAEM6fP//U7RJR1fEYOdVaP/30E+zt7VFSUgKVSoXXXnsN8+fPV7/fsmVLjePiFy5cwLVr1+Dg4KCxnqKiIly/fh05OTm4d+8eOnbsqH7PwsIC7du3rzC8Xi4uLg7m5ubo3r17pXNfu3YNBQUFeOmllzTmFxcXo23btgCAy5cva+QAgODg4Epvo9w333yD1atX4/r168jLy0NpaSkcHR012vj6+qJu3boa21GpVEhISICDgwOuX7+OMWPGYNy4ceo2paWlkMlkWuchIu2xkFOt1bNnT2zYsAFWVlbw9vaGhYXmr7udnZ3G67y8PAQFBWHHjh0V1uXm5lalDDY2Nlovk5eXBwD4+eefNQooUHbcv7pER0djxIgRWLBgAUJDQyGTybBz5058+umnWmf9/PPPK3yxMDc3r7asRPR0LORUa9nZ2aFhw4aVbt+uXTt88803cHd3r9ArLefl5YXTp0+jW7duAMp6nrGxsWjXrt0T27ds2RIqlQpHjx5FSEhIhffLRwSUSqV6XmBgIKytrXH79u2n9uSbNWumPnGv3KlTp579Qz7i5MmT8PPzw4cffqied+vWrQrtbt++jZSUFHh7e6u3Y2ZmhiZNmsDDwwPe3t5ISkrCiBEjtNo+EVUPnuxG9I8RI0agTp066N+/P44fP44bN27gyJEjeO+993Dnzh0AwMSJE7FkyRLs3bsXV65cwTvvvPOv14D7+/sjLCwMo0ePxt69e9Xr3LVrFwDAz88PEokEP/30EzIyMpCXlwcHBwdMnToVkydPxtatW3H9+nWcO3cOa9asUZ9A9tZbbyExMRHTpk1DQkICoqKisGXLFq1+3kaNGuH27dvYuXMnrl+/jtWrVz/xxD2pVIqwsDBcuHABx48fx3vvvYehQ4fC09MTALBgwQJERERg9erVuHr1Ki5evIjIyEgsX75cqzxEVDUs5ET/sLW1xbFjx+Dr64tBgwahWbNmGDNmDIqKitQ99Pfffx9vvPEGwsLCEBwcDAcHBwwcOPBf17thwwa88soreOedd9C0aVOMGzcO+fn5AIC6detiwYIFmDlzJjw8PDBhwgQAwKJFizBnzhxERESgWbNm+M9//oOff/4ZAQEBAMqOW3///ffYu3cvWrdujY0bN+Ljjz/W6ud9+eWXMXnyZEyYMAFt2rTByZMnMWfOnArtGjZsiEGDBuG///0vevXqhVatWmlcXjZ27Fh88cUXiIyMRMuWLdG9e3ds2bJFnZWIapZEeNpZOkRERGTw2CMnIiIyYizkRERERoyFnIiIyIixkBMRERkxFnIiIiIjxkJORERkxFjIiYiIjBgLORERkRFjISciIjJiLORERERGjIWciIjIiP0/Y3Jf+6zzVTEAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "disp = metrics.ConfusionMatrixDisplay.from_predictions(y_test, predicted)\n", + "disp.figure_.suptitle(\"Confusion Matrix\")\n", + "print(f\"Confusion matrix:\\n{disp.confusion_matrix}\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If the results from evaluating a classifier are stored in the form of a\n", + "`confusion matrix ` and not in terms of `y_true` and\n", + "`y_pred`, one can still build a :func:`~sklearn.metrics.classification_report`\n", + "as follows:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Classification report rebuilt from confusion matrix:\n", + " precision recall f1-score support\n", + "\n", + " 0 1.00 0.99 0.99 88\n", + " 1 0.99 0.97 0.98 91\n", + " 2 0.99 0.99 0.99 86\n", + " 3 0.98 0.87 0.92 91\n", + " 4 0.99 0.96 0.97 92\n", + " 5 0.95 0.97 0.96 91\n", + " 6 0.99 0.99 0.99 91\n", + " 7 0.96 0.99 0.97 89\n", + " 8 0.94 1.00 0.97 88\n", + " 9 0.93 0.98 0.95 92\n", + "\n", + " accuracy 0.97 899\n", + " macro avg 0.97 0.97 0.97 899\n", + "weighted avg 0.97 0.97 0.97 899\n", + "\n", + "\n" + ] + } + ], + "source": [ + "# The ground truth and predicted lists\n", + "y_true = []\n", + "y_pred = []\n", + "cm = disp.confusion_matrix\n", + "\n", + "# For each cell in the confusion matrix, add the corresponding ground truths\n", + "# and predictions to the lists\n", + "for gt in range(len(cm)):\n", + " for pred in range(len(cm)):\n", + " y_true += [gt] * cm[gt][pred]\n", + " y_pred += [pred] * cm[gt][pred]\n", + "\n", + "print(\n", + " \"Classification report rebuilt from confusion matrix:\\n\"\n", + " f\"{metrics.classification_report(y_true, y_pred)}\\n\"\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + }, + "vscode": { + "interpreter": { + "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/IA/Cours.md b/IA/Cours.md new file mode 100644 index 0000000..b7988ab --- /dev/null +++ b/IA/Cours.md @@ -0,0 +1,7 @@ +# IA de confiance + +## Cours 09/12 + +Plusieurs modules avec plusieurs profs, exam final analyse d'un article avec résumé en 1-2 pages et présentation orale. +Regarder sur la commission européenne pour les réglementations. + diff --git a/T1/TP/RADOSAVLJEVIC_STRANSKY_ROUSSET-CR_TP1-2022.pdf b/T1/TP/RADOSAVLJEVIC_STRANSKY_ROUSSET-CR_TP1-2022.pdf new file mode 100644 index 0000000..a7b5fbc Binary files /dev/null and b/T1/TP/RADOSAVLJEVIC_STRANSKY_ROUSSET-CR_TP1-2022.pdf differ